
var stx='';//路径前缀 默认为空 js里加载JS，CSS，images的时候需加上这个前缀

//jquery扩展插件
$.fn.extend({
	tableSort:function(){
		/*
		 * 功能：表格排序
		 * 调用示例:
		 * js:
		 * jQuery('.myTable').tableSort();
		 * html:
		 * <table class="myTable paginated">
		  <thead>
		    <tr>
		      <th class="str"> Last Name </th>      
		      <th class="num"> Due </th>
		      <th class="date"> Date </th>
		      <th> Web Site </th>
		    </tr>
		  </thead>
		  <tbody>
		    <tr>
		      <td> Smith </td>      
		      <td> $50.00 </td>
		      <td> Mar 2009 </td>
		      <td> http://www.codefans.net </td>
		    </tr>
		    <tr>
		      <td> amith </td>      
		      <td> $51.00 </td>
		      <td> Mar 2007 </td>
		      <td> http://www.codefans.net </td>
		    </tr>
		  </tbody>
		</table>
		 */
            var $table = $(this);  //将table存储为一个jquery对象
           
            $('thead th', $table).each(function(column) {
								
                var findSortKey;
                if ($(this).is('.str')) {       //按字符串排序
                    findSortKey = function($cell) {	
                        return $cell.find('sort-key').text().toUpperCase() + '' + $cell.text().toUpperCase();
                    };
                } else if ($(this).is('.num')) {       //按数字排序
                    findSortKey = function($cell) {
                        var key = parseFloat($cell.text().replace(/^[^\d.]*/, ''));
                        return isNaN(key) ? 0 : key;
                    };
                } else if ($(this).is('.date')) {          //按日期排序
                    findSortKey = function($cell) {
                        return Date.parse('1 ' + $cell.text());
                    };
                }


                if (findSortKey) {
                    $(this).addClass('clickable').hover(function() { $(this).addClass('hover'); }, function() { $(this).removeClass('hover'); }).click(function() {
                        //反向排序状态声明
                        var newDirection = 1;
                        if ($(this).is('.sorted-asc')) {
                            newDirection = -1;
                        }
                        var rows = $table.find('tbody>tr').get(); //将数据行转换为数组
                        $.each(rows, function(index, row) {
                            row.sortKey = findSortKey($(row).children('td').eq(column));
                        });
                        rows.sort(function(a, b) {
                            if (a.sortKey < b.sortKey) return -newDirection;
                            if (a.sortKey > b.sortKey) return newDirection;
                            return 0;
                        });
                        $.each(rows, function(index, row) {
                            $table.children('tbody').append(row);
                            row.sortKey = null;
                        });

                        $table.find('th').removeClass('sorted-asc').removeClass('sorted-desc');
                        var $sortHead = $table.find('th').filter(':nth-child(' + (column + 1) + ')');
                        //实现反向排序
						$table.find('th .asc').remove();
						$table.find('th .desc').remove();
                        if (newDirection == 1) {
                            $sortHead.addClass('sorted-asc').append("<span class='asc'>↓</span>");
							
							
                        } else {
                            $sortHead.addClass('sorted-desc').append("<span class='desc'>↑</span>");
							//$sortHead.find('.up').remove();
                        }

                        //调用隔行变色的函数
                       // $table.alternateRowColors($table);
                        //移除已排序的列的样式,添加样式到当前列
                        $table.find('td').removeClass('sorted').filter(':nth-child(' + (column + 1) + ')').addClass('sorted');
                        $table.trigger('repaginate').trDif();
						
                    });
                }
            });
				//return this;
            },
	
trDif:function(){
		/*
 		* 功能：表格隔行换色
 		* 调用示例:jQuery('#id').trDif()
 		*/	
		
		
	 $('tbody tr:odd', this).removeClass('tr-01').addClass('tr-02'); //隔行变色 奇数行
     $('tbody tr:even',this).removeClass('tr-02').addClass('tr-01'); //隔行变色 偶数行
      return this;
	},
	createForm:function(options){
	/*
	功能：
	表单创建
	*/
			var obj=$(this);
			$.getScript(stx+'/js/jquery/createForm.js',function(){
					$(obj).createForm(options);					   
			});
	},		

	verifyForm : function(options) { 
	/*
	功能：
	为表单绑定校验事件，这是一个表单绑定入口，主要调遍历校验 verifyInput() 进行处理
	参数：
	formId:(str) 表单对象 ID ，一般用于提交按钮位于表单以外的时候需要传该对像
	blurCheck:(boolean)焦点离开时校验，默认为true,校验
	focusLight:(boolean)获得焦点时控件样式改变，默认true,改变
	sendText:(str)加载中时的文字内容
	sendCls:(str)加载中按钮调用的样式名，默认在原基础样式名上加 _send,如  原为：class="btn1" ,则在后面加 class="btn1 btn1_send"
	callBack:(fn)校验通过后的回调函数
	
	控件 parameter 属性参数：
	type:(str) 校验类型，类型包括：select(为模拟select控件校验),mobile(移动手机),tel(固话),str(字符串),en(英文，可含数字),date(日期),cn(中文),mail(电子邮箱),url(网址),path(目录路径),idCard(身份证),num(整数),str(字符串),decimal(小数),editor(编辑器)
	text:(str)控件默认显示value值
	minLen:(int)最少输入字符长度
	maxLen:(int)最大输入字符长度
	conf:(str)一般为确认密码时使用，值对为要确认控件的名称(name)
	callTips:(fn)检验失败或成功后的提示函数，默认 inputTips();
	iTips:(boolnea) 控件获得焦点后是否显示提示信息，默认为true 显示，false为不显示
	need:(boolean) 是否为必填字段，默认为true必填，false为非必填，即空值时不校验，非空值时校验
 	
	使用示例：
	<form>
	<input type="text"  value="请输入" parameter="{type:'str',minLen:6,maxLen:12,text:'请输入'}"/>
	<button id="send">提交</button>
	</form>
	$('#send').verifyForm();		// 注意是调用form中的提交按钮对象
	*/
	
		var sendBtn;	//表单提交按钮对象
		var defaults = {
			blurCheck : true,
			focusLight : true,
			iTips : true
		}
		
		var settings = $.extend(defaults, options);	
		var formId = settings.formId;
		sendBtn = settings.sendBtn;
		iTips = settings.iTips;
		var callBack = settings.callBack;
		
		var form;
		
		if (formId != undefined) {		
			form = $("#"+formId); 
		} else {					//如果没提供表单ID，即默认为提交按钮当前表单的ID
			form = $(this).parents("form");
		};
		
		if (form.length < 0) {
			alert('表单不存在！');
			return null;
		}
		
		$(form).defValue();		//为表单存在默认value值的控件添加显示层
		
		var _input = form.find("input");
		var _textarea = form.find("textarea");
		var input = form.find("input[parameter]");	
		var textarea = form.find("textarea[parameter]");//查找含有parameter属性的表单控件对象
		if (settings.focusLight) {		
			_input.bind({
				focus:function() {	//为表单中所有input绑定获焦状态方法
					focusLight(this);
				}
			});	
			_textarea.bind({
				focus:function() {	//为表单中所有textarea绑定获焦状态方法
					focusLight(this);
				}
			});	
		}
		if (settings.blurCheck) {	
			var parameter;
			input.each(function(i) {
				switch (input.eq(i).attr("type")) {
				/*
				case "hidden":	//该类型的通常为自行定义的模拟控件，如模拟select下拉列表
				if(input.eq(i).attr("parameter").type=="select"){	//如果类型为模拟下拉列表控件
				}
				break;
				*/
				case "checkbox":
					var _o = $("input[name='"+input.eq(i).attr("name")+"']").not(':[type="hidden"]');
					
					parameter = evalJSON($(_o).eq(0).attr("parameter"));
					
					var _minLen = parameter.minLen || 0;
					var _maxLen = parameter.maxLen || _o.length;
					
					for (var n=0; n<_o.length; n++) {
						_o.eq(n).blur(function() {
							var _checkedObj = $("input[name='"+$(this).attr("name")+"']:checked");
							
							if (_minLen <= _checkedObj.length && _maxLen >= _checkedObj.length) {		//如果checkbox控件选择的数量小于最少指定数，或大于最少指定数，即不通过
								inputTips({obj:$(this), status:true});
							} else {
								inputTips({obj:$(this), status:false});
							};	   
						}).click(function() {
							var _checkedObj = $("input[name='"+$(this).attr("name")+"']:checked");
							var parameter = evalJSON($(_o).eq(0).attr("parameter"));
							
							if (parameter.beforeCheck != undefined) {	//如果参数存在校验前的执行函数
								if (typeof(parameter.beforeCheck) == "string") {//如果执行函数为字符号
									eval(parameter.beforeCheck);
								} else {	
									if (parameter.beforeCheck != undefined) parameter.beforeCheck();	
								}
							}
							
							if (_minLen <= _checkedObj.length && _maxLen >= _checkedObj.length) {		//如果checkbox控件选择的数量等于最少指定数，或等于最少指定数，即通过
								inputTips({obj:$(this), status:true});
							} else {	//否则不通过
								inputTips({obj:$(this), status:false});
								inputTipsText({obj:$(_o).eq(0)});
							};
						});
					}
					break;
					
				case "radio":
					var _o = $("input[name='"+input.eq(i).attr("name")+"']");		
					
					for(var n=0; n<_o.length; n++) {	
						_o.eq(n).focus(function() {
							var parameter = evalJSON($(_o).eq(0).attr("parameter"));
							if (parameter.beforeCheck != undefined) {	//如果参数存在校验前的执行函数
								if(typeof(parameter.beforeCheck) == "string") {//如果执行函数为字符号
									eval(parameter.beforeCheck);
								} else {
									if (parameter.beforeCheck != undefined) parameter.beforeCheck();
								}
							}
							inputTips({obj:$(this), status:true});					   
						});
					}
					break;
					
				default:
					parameter = evalJSON($(input.eq(i)).attr("parameter"));
					input.eq(i).bind({
						focus:function() {  //则为控件绑定失焦校验方法
							verifyInput({obj:input.eq(i)});  //调用校验方法
						}
					});
					break;
				}
			});
			textarea.each(function(i) {
				parameter = evalJSON($(this).attr("parameter"));
				$(this).editorTxtCount({maxLen: parameter.maxLen, txtCount: parameter.txtCount, type: parameter.type});
				$(this).bind({
					focus: function() {  //则为控件绑定失焦校验方法
						$(this).editorTxtCount({maxLen: parameter.maxLen, txtCount: parameter.txtCount, type: parameter.type});
						verifyInput({obj:this});  //调用校验方法
					}
				});
			});
		}
		form.find(":[type='reset']").click(function() {  //如果控件为重置按钮，即绑定重置时清除表单中的正确，错误提示标签
			form.find('.inputErr').remove();
			form.find('.inputOk').remove();
		});
		
		$(this).bind({
			click: function() {			//为表单提交按钮绑定事件
				//alert(verifyInput({obj:this,sendText:settings.sendText,sendCls:settings.sendCls}));
				//return false;
				form.find('.inputErr').remove();
				if (verifyInput({obj:this, formId:formId, sendText:settings.sendText, sendCls:settings.sendCls})) {
					if (callBack != undefined) {
						if (typeof(callBack) == "string") {//如果回调方法传入为字符串类型
							eval(callBack);
						} else {
							callBack();
						};
					}
					form.find('.inputOk').remove();		//当表单通过本地校验时，把所有正确的标签删除
					return true;	//同时返回true
				} else {
					return false;
				}
			}
		});
			
		if (iTips) focusTips(form);	//绑定控件获得焦点后加载提示方法
	},
	defValue:function(options){
			/*
			功能:
			控件默认值显示
			控件parameter参数：
			value:(str) 控件的默认值，格式如： <input type="text" parameter="{value:'请输入'}"/>
			使用示例：
			<form id="test">
			<input type="text" parameter="{value:'请输入'}"/>
			</form>
			$('#test').defValue();
			*/
			
			var _input=$(this).find('input[parameter]');
			var _textarea=$(this).find('textarea[parameter]');
			
			function _defVal(o,i){
			
				var offSet=$(o).offset();
			//	var _name=$(o).attr('name');
				//var _valId=$(o).attr('name').replace('.','');	//由于jq不支持 带 . 名称的id ，所以防止name 中带有 . 符号，此处把 .符号过滤掉再进行id赋值
				var _name="";
				if($(o).attr('name')!=undefined)  _name=$(o).attr('name').replace(/\./g,'');	//由于jq不支持 带 . 名称的id ，所以防止name 中带有 . 符号，此处把 .符号过滤掉再进行id赋值
				var _p=evalJSON($(o).attr("parameter"));
				var _style;
				//alert(offSet.left);
				
				var _offSet=$(o).offsetParent().offset();
				var __left=offSet.left-_offSet.left;
				var __top=offSet.top-_offSet.top;
			//	alert($(o).offsetParent().left);
				if(_p!=undefined){
				
					if(_p.value!=undefined){
						_style='height:'+$(o).height()+'px;line-height:'+$(o).height()+'px;top:'+__top+'px;left:'+__left+'px;';
						if($(o).siblings('.defVal').length==0)$(o).after('<label id="'+_name+i+'" class="defVal" style="'+_style+'">'+_p.value+'</label>');
					}
				}
				$('#'+_name+i).one('click',function(){$(o).focus();});
				$(o).focus(function(){
					$(o).parents('form').find('#'+_name+i).remove();	//本对象当前表单中的默认值删除
					//$('#'+_name+i).remove();	
					
				}).blur(function(){
					 _p=evalJSON($(this).attr("parameter"));
						 offSet=$(this).offset();	//考虑窗体变化时，重新定位其座标
						var _offSet=$(o).offsetParent().offset();
						var __left=offSet.left-_offSet.left;
				//	if(_p!=undefined){
					 if(_p.value!=undefined){
						if($(o).val()==""){
							if($(o).siblings('.defVal').length==0)$(o).after('<label id="'+_name+i+'" class="defVal"  style="'+_style+'">'+_p.value+'</label>');
						}else if($(o).val()==_p.value){
							$(o).val("");
							if($(o).siblings('.defVal').length==0)$(o).after('<label id="'+_name+i+'" class="defVal"  style="'+_style+'">'+_p.value+'</label>');
						}
					 }
					 $('#'+_name+i).css({'left':__left});	//考虑窗体变化时，重新定位其座标
				//	}
				$('#'+_name+i).one('click',function(){$(o).focus();});
				});
				
				
			if($('#'+_name+i).length>0){
					$(window).resize(function(){
						var offSet=$(o).offset();
						
						var _offSet=$(o).offsetParent().offset();
						var __left=offSet.left-_offSet.left;
						var __top=offSet.top-_offSet.top;
						
						var _name=$(o).attr('name');
						$('#'+_name+i).css({'top':__top,'left':__left});
					
				});	
			}
					
				
			}
			
			//if($('#'+_name+i)!=undefined){
			
			_input.each(function(i){
			 // alert($('label[id="'+$('#'+$(_input.eq(i)).attr('name').replace('.',''))+'"]').length);
				//alert($('#'+$(_input.eq(i)).attr('name').replace('.','')).attr('id')); 			 
		//	 if($('#'+$(_input.eq(i)).attr('name').replace('.','')).length==0)_defVal(_input.eq(i),i);	//replace过滤了 name 中的. ，由于jq不支持带.的id

		if(_input.eq(i).attr('name')!=undefined)if($('label[id="'+$('#'+$(_input.eq(i)).attr('name').replace('.',''))+'"]').length==0)_defVal(_input.eq(i),i);	//replace过滤了 name 中的. ，由于jq不支持带.的id
		
		
		
		//	if($('#'+$(_input.eq(i)).attr('name')+i).length==0)_defVal(_input.eq(i),i);	 		//判断默认值显示层标签是否存在，如果不存在则执行插入
								
							
			});
			_textarea.each(function(i){
			if(_textarea.eq(i).attr('name')!=undefined)if($('label[id="'+$('#'+$(_textarea.eq(i)).attr('name').replace('.',''))+'"]').length==0)_defVal(_textarea.eq(i),i);		//replace过滤了 name 中的. ，由于jq不支持带.的id		 
				 
				 
				//if($('#'+$(_textarea.eq(i)).attr('name')+i).length==0)_defVal(_textarea.eq(i),i);	//判断默认值显示层标签是否存在，如果不存在则执行插入
			});
		
			
			//}
	
	},
	formTxtCount:function(){
		/*
		功能：对表单中parameter属性含有 txtCount参数的对象进行输入字长统计显示
		使用示例：
		<form name="f1" id="f1">
		<textarea id="a" rows="4" cols="20" parameter="{txtCount:true,maxLen:20}" ></textarea>
		<textarea id="c" rows="4" cols="20"  parameter="{txtCount:true,maxLen:10}"></textarea>
		</form>
		<script>
		$('#f1').formTxtCount();
		</script>
		*/
			var _input=$(this).find('input[parameter]');
			var _textarea=$(this).find('textarea[parameter]');
			
			_textarea.each(function(i){
				var par=evalJSON(_textarea.eq(i).attr('parameter'));
				var maxLen;
					if(par.txtCount){	//如果txtCount为true
						    if(par.maxLen!=undefined){
								maxLen=par.maxLen;
							}else{
								maxLen=_textarea.eq(i).attr('maxlength');
							}
							_textarea.eq(i).countTxtContent({maxLen:maxLen});
					}
									
			});
			
			_input.each(function(i){	
				var par=evalJSON(_input.eq(i).attr('parameter'));
				var maxLen;
					if(par.txtCount){	//如果txtCount为true
						    if(par.maxLen!=undefined){
								maxLen=par.maxLen;
							}else{
								maxLen=_input.eq(i).attr('maxlength');
							}
							_input.eq(i).countTxtContent({maxLen:maxLen});
					}
			});
			
			

	},
	toolTips:function(options){
	/*
		功能：
		内容提示层
		参数：
		cls:(str)浮动层样式名，默认toolTips
		width:(int)层的宽,默认auto
		height:(int)层的高,默认auto
		zIndex:(int)层的层级,默认3000
		x:(int)相对对象的x座标
		y:(int)相对对象的y座标
		evt:(str)触发展开类型，默认为mouseover,可选 click
		overTime:(int)鼠标离开层后，层隐藏的时间，默认500ms
		closeBtn:(boolean) 弹出层是否存在关闭按钮，默认false不存在，ture为存在，当为ture时，鼠标离开弹出层范围，层不会自动关闭，需手动点击关闭按钮关闭提示层
		使用示例：
		<a href="javascript:void(0);" id="toolTips">点击弹出对话</a>
		$("#toolTips").toolTips({tipsText:'点击弹出对话点击弹出对话点击弹出对话',width:200});
	*/
	
		var left=$(this).offset().left;
		var top=$(this).offset().top;
		var _w=$(this).width();
		var _h=$(this).height();
		var defaults={	//默认值
			evt:'mouseover',
			tipsText:'请传入提示层内容！',
			cls:'toolTips',
			width:'auto',
			height:'auto',
			zIndex:3000,
			x:left+_w,
			y:top+_h,
			overTime:500,
			closeBtn:false
		}
		var settings=$.extend(defaults,options);	
		var tipsText=settings.tipsText;
		var evt=settings.evt;
		var width=settings.width;
		var height=settings.height;


		var cls=settings.cls;
		var zIndex=settings.zIndex;
		var x=settings.x;
		var y=settings.y;
		var overTime=settings.overTime;
		var closeBtn=settings.closeBtn;
		var obj=$(this);	
		
		
		var btnHtml="";
		if(closeBtn){
		 btnHtml='<i class="toolTipsClose" style="position:absolute;top:0;right:0;cursor:pointer; font-family:Arial;font-style:normal;" onclick="$(this).parent().hide();">x</i>';
		}
		var html='<div  style="display:none;zIndex:'+zIndex+';word-wrap:break-word;word-break:break-all; position:absolute;left:'+x+'px;top:'+y+'px;width:'+width+'px;height:'+height+'px;" class="'+cls+'">'+tipsText+btnHtml+'</div>';
		obj.after(html);
		var t;
		obj.bind(evt,function(){
			if(!closeBtn)clearInterval(t);	
			obj.next("div").show();
		}).mouseout(function(){
			if(!closeBtn)t=setInterval(autoTrun,overTime);
		});
		
		obj.next("div").mouseover(function(){
			if(!closeBtn)clearInterval(t);	
			obj.next("div").show();
		}).mouseout(function(){
			if(!closeBtn)t=setInterval(autoTrun,overTime);
		});
		
		function autoTrun(){	//自动切换函数
			obj.next("div").hide();
		}
		
	},/*
	loadBar:function(options){
		
		功能：
		进度条
		参数：
		tipsText:(str) 加载条提示文字内容
		callBack:(fn) 加载完成后的回调函数
		align:(str) 加载条座标位置 默认(center)居中，其它数： 左上角(left)，右上角(right)
		lock:(boolean)加载时是否锁屏，默认true锁屏，false为不锁屏
		width:(int) 加载条宽
		height:(int)加载条高
		img:(str)加载条的loadding图片,默认/images/v2012/public/loadImg_1.gif'
		finish:(boolean)加载是否完成，默认为false，未过完成，ture为完成，完成时移除加载条
		zIndex:(int) 加载条层级，默认10000
		示例：
		显示加载条
		$("body").loadBar();
		清除加载条
		$("body").loadBar({finish:true});
		
		var defaults={	//默认值
		tipsText:'正在处理...',
		lock:true,
		align:'center',
		width:200,
		height:50,
		img:'/images/v2012/public/loadImg_1.gif',
		finish:false,
		zIndex:10000
		}
		
		var x=$(this).offset().left;
		var y=$(this).offset().top;
		var settings=$.extend(defaults,options);	
		var tipsText=settings.tipsText;
		var align=settings.align;
		var width=settings.width;
		var height=settings.height;
		var img=settings.img;
		var finish=settings.finish;
		var callBack=settings.callBack;
		var lock=settings.lock;
		var zIndex=settings.zIndex;
		var html='<div class="loadding" style="left:'+x+'px;top:'+y+'px;background:#fff;position:absolute;z-index:'+zIndex+';border:1px solid red;width:'+width+'px;height:'+height+'px;"><img src="'+img+'"/>'+tipsText+'</div>';
	
		if(finish){		//如果为true加载完成
			$(this).children(".loadding").remove();
			unblockUI();	//解屏
			if(callBack!=undefined)callBack();
			return false;
		}else{
			
			if(lock)blockUI();
			if($(this).children(".loadding").length==0)$(this).append(html);
		}
			var obj=$(this).children(".loadding");
			switch(align){
				case "left":
				break;
				case "right":
					if($(this).attr("tagName")=="BODY"){		//如果容器标签为BODY
					y=0;
					var _w=$("body").width();
						x=_w-obj.width()-2;
					}else{
						x=$(this).width()-obj.width()+x;
					}
				break;
				default:
					if($(this).attr("tagName")=="BODY"){		//如果容器标签为BODY
					var _h;
						if($.browser.msie){
							 _h= document.compatMode== "CSS1Compat"? document.documentElement.clientHeight : document.body.clientHeight;
						}
						else {
							_h= self.innerHeight;
						}
					
					var _w=$("body").width();
						x=_w/2-obj.width()/2;
						y=_h/2-obj.height()/2;
					}else{
						x=$(this).width()/2-obj.width()/2;
						y=$(this).height()/2-obj.height()/2;
					}
				break;
			}		
				obj.css({left:x,top:y});
	},*/
 
 	createTable:function(options){
	/*
		功能：创建表格入口，主要调用createForm()完成输出，本接口主要为区分创建表单与创建表格
		参数：
		详细见：
		createForm()
	*/
	$(this).createForm(options);
	},
	
	
	verifySendForm:function(options){
			/*
			功能：
			带校验的表单ajax提交数据接口，主要通用调用 verifyForm() 及 sendForm() 来完成
			参数：
			//校验部分
			blurCheck:(boolean)焦点离开时校验，默认为true,校验
			focusLight:(boolean)获得焦点时控件样式改变，默认true,改变
			sendText:(str)加载中时的文字内容
			sendCls:(str)加载中按钮调用的样式名，默认在原基础样式名上加 _send,如  原为：class="btn1" ,则在后面加 class="btn1 btn1_send"
			
			//提交部分
			formId:(str) 表单对象 ID ，一般用于提交按钮位于表单以外的时候需要传该对像
			url:(str) ajax请求的URL地址，默认为获取form的action属性
			method:(str)提交的方式，默认为post ，可选get
			data:(JSON) 附加的提交数据 
			callBack:(fn) 执行成功后的回调方法
			error:(fn) 提交失败后的回调方法
			beforeSend:(fn)提交时执行的方法
			finisLock:(boolean) 提交完成后，是否解除屏幕锁定，默认为false 解屏，true为不解屏
			timeout:(int) 设置请求超时时间（毫秒），没默认值
			示例：
			
			<script>
			
			<form>
				<input type="text" name="userName"/>
				<button id="send">提交</button>
			</form>
			<button id="sendId">位置表单外的提交</button>
			
			jQuery(function(){
			
				jQuery("#sendId").verifySendForm({		//位置于表单外部的提交按钮
					formId:'f1',						//需要传form的 id
					callBack:sendOk,
					beforSend:prossFn,
					error:errFn,
					data:{userName:'jone',age:16}
				});
				
				jQuery("#send").verifySendForm({		//位置表单内部的提交按钮，不需传form id
					callBack:sendOk,		
					beforSend:prossFn,
					error:errFn
				});
			});
			</script>
			
			*/
		var defaults={	//默认值
			url:$(this).parents("form").attr("action"),
			method:'post',
			data:'',
			callBack:'',
			error:'',
			beforeSend:'',
			finisLock:false
		}
		var settings=$.extend(defaults,options);	
		
		var formId=settings.formId;
		var sendBtn=$(this);
		
		var blurCheck=settings.blurCheck;
		var focusLight=settings.blurCheck;
		var sendText=settings.sendText;
		var sendCls=settings.sendCls;

		var data=settings.data;
		var method=settings.method;
		var url=settings.url;
		var callBack=settings.callBack;
		var error=settings.error;
		var beforeSend=settings.beforeSend;
		var timeout=settings.timeout;
		var finisLock=settings.finisLock;
		
		
		if(formId==undefined){	//如果参数没有传入form的id，则默认提钮位于form里面
			var f=$(this).parents('form');
 			$(this).verifyForm({sendText:sendText,sendCls:sendCls,blurCheck:blurCheck,focusLight:focusLight,
		
			callBack:function(){
					
				sendForm({obj:f,url:url,finisLock:finisLock,timeout:timeout,callBack:callBack,beforeSend:beforeSend,error:error,data:data});
			
			}
			});
		}else{		//否则，则校验并提交指定的form对象
			var f=$("#"+formId);
			if(url==undefined)url=f.attr("action");
			$(sendBtn).verifyForm({formId:formId,
			sendText:sendText,sendCls:sendCls,blurCheck:blurCheck,focusLight:focusLight,
			callBack:function(){
				sendForm({obj:f,url:url,finisLock:finisLock,timeout:timeout,callBack:callBack,beforeSend:beforeSend,error:error,data:data});
			}
			});
		}
	},
	changeCls:function(options){
	/*
		功能：触发对象改变对象的样式，常用于控件获得焦点，或移动条目后改变样式
		参数：
		cls:(str)触发后对象获得的样式名称，默认为 on
		evt:(evt)触发的动作，默认为mouseover,可选，focus,click
		使用示例：
		<ul id="demo1">
			<li><a href="">条目1</a></li>
			<li><a href="">条目2</a></li>
		</ul>
		$("#demo1").changeCls();
	*/
	
		var defaults={	//默认值
			cls:'on',
			evt:'mouseover'
		}
		var settings=$.extend(defaults,options);	
		var cls=settings.cls;
		var evt=settings.evt;
		
		switch(($(this)[0].tagName)){
		
			case "TABLE":
			
			//jQuery("#optionsTb tr:gt(0)").changeCls();	//鼠标划过行变色 
			
			$(this).find('tbody tr').bind(evt,function(){
			$(this).addClass(cls);
			}).mouseout(function(){
				$(this).removeClass(cls);
			});
			break;
			case "UL":
			$(this).children('li').bind(evt,function(){
			$(this).addClass(cls);
			}).mouseout(function(){
				$(this).removeClass(cls);
			});

			break;
		}
		
		
		$(this).bind(evt,function(){
			$(this).addClass(cls);
		}).mouseout(function(){
			$(this).removeClass(cls);
		});
	},

/*
   JQuery dropdownlist 代替系统默认下拉框
 
	参数说明
	id:'',//假设id为dr1,则可以用方法dr1.disable(),dr1.enable(),dr1.init(data,selected)/可用作联动/,dr1.text,dr1.value;$('#dr1').val();dr1.onchange=callBack	
	width:100,//显示宽
	listboxwidth:0,//下拉框宽为0表示同上面的显示宽度
	listboxmaxheight:200,//下拉框最大高度，超过即显示滚动条
	listboxalign:'auto',//下拉列表的对齐方式，可选值left,right,auto
	columns:1, //显示列数
	checkbox:false,//是否复选
	maxchecked:3,//最多同时选择数，checkbox=true时有效
	selectedtext:'',//checkbox=true时有效,选择框文字,为空显示为选中项，非空时固定不变
	requiredvalue:[],//必须选择的值,显示为不可点击状态，checkbox=true时有效，
	disabled:false,//是否禁用
	selectclass:'ddl-select',//选框样式
	listboxclass:'ddl-listbox',//展开的列表框样式
	selected:[],//选中的对象value，
	data:{},//数据，格式：{value:name}
	onchange:null
*/
	dropdownlist:function(opts){
		/*
		功能：模拟select控件
		*/
			var obj=$(this);
			$.getScript(stx+'/js/v2012/jquery/dropdownlist/dropdownlist.js',function(){
				$(obj).dropdownlist(opts);			   
			});
	},
	
	jCarouselLite:function(o) {
		/*
		功能：图片滚动
		*/
			var obj=$(this);
			$.getScript(stx+'/js/v2012/jquery/jCarouselLite.js',function(){
				$(obj).jCarouselLite(o);
			});
	},   
	center:function(pos){ 
		/*
		jQuery 居中插件
		*/
	var $this=$(this); 
	var pNode =(!pos)?$this.parents('body'):$(pos);
	
	var l = (pNode.width()-$this.width())/2;
	var _iframe=$(window.parent.parent.document).find('.tabContent[display!="none"]').find('iframe');	//找到不为隐藏的切换层下面的唯一iframe
	var t = 0;
	if(_iframe.length==0){	//如果不存在iframe，即为当前页高度
	
		
	t=pNode.scrollTop()+pNode.height()/2-$this.outerHeight()/2;	
	
		
	}else{			//如果存在iframe
	
	
		if($(window.parent).scrollTop()==0){
			t=pNode.scrollTop()+$(_iframe).height()/2-$this.outerHeight()/2;
		}else{
			t=$(window.parent).scrollTop()+$(_iframe).height()/2-$this.outerHeight()/2;
		}
	}
	
	$this.css({left:l,top:t});
		
	
	return this;
	
    },
	bgiframe:function(s) {
	/**
	功能：修复IE6弹出层不能够遮住下拉框的BUG
	 * This is only for IE6
	 * @example $('div').bgiframe();
	 * @before <div><p>Paragraph</p></div>
	 * @result <div><iframe class="bgiframe".../><p>Paragraph</p></div> 
	 */
	if ( $.browser.msie && /6.0/.test(navigator.userAgent) ) {
		s = $.extend({
			top     : 'auto', // auto == .currentStyle.borderTopWidth
			left    : 'auto', // auto == .currentStyle.borderLeftWidth
			width   : 'auto', // auto == offsetWidth
			height  : 'auto', // auto == offsetHeight
			opacity : true,
			src     : 'javascript:false;'
		}, s || {});
		var prop = function(n){return n&&n.constructor==Number?n+'px':n;},
		    html = '<iframe class="bgiframe" frameborder="0" tabindex="-1" src="'+s.src+'"'+
		               'style="display:block;position:absolute;z-index:-1;'+
			               (s.opacity !== false?'filter:Alpha(Opacity=\'0\');':'')+
					       'top:'+(s.top=='auto'?'expression(((parseInt(this.parentNode.currentStyle.borderTopWidth)||0)*-1)+\'px\')':prop(s.top))+';'+
					       'left:'+(s.left=='auto'?'expression(((parseInt(this.parentNode.currentStyle.borderLeftWidth)||0)*-1)+\'px\')':prop(s.left))+';'+
					       'width:'+(s.width=='auto'?'expression(this.parentNode.offsetWidth+\'px\')':prop(s.width))+';'+
					       'height:'+(s.height=='auto'?'expression(this.parentNode.offsetHeight+\'px\')':prop(s.height))+';'+
					'"/>';
		return this.each(function() {
			if ( $('> iframe.bgiframe', this).length == 0 )
				this.insertBefore( document.createElement(html), this.firstChild );
		});
	}
	return this;
},
	countTxtContent : function(options) {
		/*
		功能：控件输入提示字符长度
		选项：
		maxLen:(int) 最大输入长度
		使用示例：
		<textarea id="b" rows="4" cols="20" ></textarea>
		$('#b').countTxtContent();
		*/
		var obj = $(this);
		var defaults = {	//默认值
			maxLen : 200
		}
		var settings = $.extend(defaults, options);
		var limit = settings.maxLen * 2;
	    obj.after('<p class="limit">还可以输入<span>' + settings.maxLen + '</span>个字符</p>');
		function len(s) {//获取字符串的字节长度 
			var s = String(s);
			return s.length + (s.match(/[^\x00-\xff]/g) || '').length;//加上匹配到的全角字符长度 
		}
		obj.bind('keyup', function() {
			var val = $(this).val();
			if (len(val) > limit) { 
				while (len(val = val.substr(0, val.length-1)) > limit); 
				$(this).val(val); 
			}
			obj.nextAll('.limit:eq(0)').find('span:eq(0)').html(parseInt(parseInt(limit-len($(this).val()))/2));
		});
	},
	editorTxtCount : function(options) {
		/**
		 * 配合editor校验类型，实时输出当前输入信息
		 **/
		var obj = $(this);
		var defaults = {
			type : '',
			maxLen : 0,
			txtCount : false
		}
		var settings = $.extend(defaults, options);
		
		var maxLen = settings.maxLen,
			txtCount = settings.txtCount,
			type = settings.type,
			len = type ? getEditorStringLength(obj.val()) : $(this).val().length;
		var limit = obj.nextAll('.limit:eq(0)');
		if (!limit.length) {  //初始化。如果不存在.limit，则新建并插入到输入框之后
			if (txtCount) {
				if (maxLen) {
					obj.after('<p class="limit">当前输入字符个数<span style="color:green;">0</span>/<span style="color:red;">' + maxLen + '</span></p>');
				} else {
					obj.after('<p class="limit">当前输入字符个数<span style="color:red;">' + len + '</span></p>');
				}
			}
		} else {  //如果存在.limit，则修改其文字内容
			if (txtCount) {
				if (maxLen) {
					limit.html('当前输入字符个数<span style="color:green;">' + len + '</span>/<span style="color:red;">' + maxLen + '</span>');
				} else {
					limit.html('当前输入字符个数<span style="color:red;">' + len + '</span>');
				}
			}
		}
		obj.bind('keyup', function() {
			len = type ? getEditorStringLength(obj.val()) : $(this).val().length;
			if (txtCount) {
				if (maxLen) {
					limit.html('当前输入字符个数<span style="color:green;">' + len + '</span>/<span style="color:red;">' + maxLen + '</span>');
				} else {
					limit.html('当前输入字符个数<span style="color:red;">' + len + '</span>');
				}
			}
		});
	}
});

$.extend({ 
   /*
   将javascript数据类型转换为json字符串
   待转换对象,支持object,array,string,function,number,boolean,regexp 
   返回json字符串 
   使用示例：
   var j=$.toJSON(json);
   */ 
   toJSON: function(object) { 
     var type = typeof object; 
     if ('object' == type) { 
       if (Array == object.constructor) type = 'array'; 
       else if (RegExp == object.constructor) type = 'regexp'; 
       else type = 'object'; 
     } 
     switch (type) { 
     case 'undefined': 
     case 'unknown': 
       return; 
       break; 
     case 'function': 
     case 'boolean': 
     case 'regexp': 
       return object.toString(); 
       break; 
     case 'number': 
       return isFinite(object) ? object.toString() : 'null'; 
       break; 
     case 'string': 
       return '"' + object.replace(/(\\|\")/g, "\\$1").replace(/\n|\r|\t/g, function() { 
         var a = arguments[0]; 
         return (a == '\n') ? '\\n': (a == '\r') ? '\\r': (a == '\t') ? '\\t': "" 
       }) + '"'; 
       break; 
     case 'object': 
       if (object === null) return 'null'; 
       var results = []; 
       for (var property in object) { 
         var value = jQuery.toJSON(object[property]); 
         if (value !== undefined) results.push(jQuery.toJSON(property) + ':' + value); 
       } 
       return '{' + results.join(',') + '}'; 
       break; 
     case 'array': 
       var results = [];
       for (var i = 0; i < object.length; i++) { 
         var value = jQuery.toJSON(object[i]); 
         if (value !== undefined) results.push(value); 
       } 
       return '[' + results.join(',') + ']'; 
       break; 
     } 
   } 
});


function sendForm(options){
		/*
		功能：
		表单ajax提交表单数据
		参数：
		obj:(obj) 表单的对象，如 jQuery("#f1")
		url:(str) 请求的URL地址
		method:(str)提交的方式，默认为post ，可选get
		data:(JSON) 附加的提交数据 
		callBack:(fn) 执行成功后的回调方法
		error:(fn) 提交失败后的回调方法
		beforeSend:(fn)提交时执行的方法
		timeout:(int) 设置请求超时时间（毫秒），没默认值
		finisLock:(boolean) 提交完成后，是否解除屏幕锁定，默认为false 解屏，true为不解屏，
		示例1：
		<form action="table5.shtml" id="f1">
			<input type="text" name="userName"/>
			<button  type="button" onclick=""sendForm({obj:jQuery('#f1'),data:{user:'张三',age:'boy'}});>send</button>
		</form>
		
		示例2：（带表单校验的）
		<form action="table5.shtml" id="f1">
			<input type="text" name="userName"/>
			<button  type="button" id="send" >send</button>
		</form>
		jQuery('#send').verifyForm({sendText:'正在提交',callBack:"sendForm({obj:$('#f1'),data:{user:'张三',age:'boy'}})"});		//校验成功后调用回调方法 sendForm()进行提交
		*/

	
	var defaults={	//默认值
		url:$(options.obj).attr("action"),
		method:'post',
		data:'',
		callBack:'',
		error:'',
		beforeSend:'',
		finisLock:false
	}

	var settings=$.extend(defaults,options);	
	var obj=settings.obj;
	var data=settings.data;
	var method=settings.method;
	var url=settings.url;
	var callBack=settings.callBack;
	var error=settings.error;
	var beforeSend=settings.beforeSend;
	var finisLock=settings.finisLock;
	var timeout=settings.timeout;
		//alert(url);
	var _data="";
	for(x in data){
		_data+="&"+x+"="+encodeURI(data[x]);
	}
	
	 data=$(obj).serialize()+_data;	//组装数据
	
	 $.ajax({
	   type: method,
	   url: url,
	   data: data,
	   timeout:timeout,
	   beforeSend:function(){
	   //	$("body").loadBar();
	  loadingfunc();
		if(beforeSend!="")beforeSend();
	   },
	   success:function(msg){
	   	if(callBack!="")callBack(msg);
	 	
	//if(!finisLock)$("body").loadBar({finish:true});//为false时，默认发送处理完成后，解除屏幕布锁定
		if(!finisLock)loadingfunc({isHide:true});//为false时，默认发送处理完成后，解除屏幕布锁定
	   },
 	   error:function(){
	  // 	$("body").loadBar({finish:true});
	  loadingfunc({isHide:true});
		if(error!="")error();
	   }
	   
}); 
}  


/*
function getColumn(options){
	
	功能：//加载排序
	
			$.getScript(stx+'/js/v2012/jquery/setColumn.js',function(){
				getColumn(opts);			   
			});
}


function setColumn(options){
	
	功能：//保存排序
	
			$.getScript(stx+'/js/v2012/jquery/setColumn.js',function(){
				setColumn(opts);			   
			});
}
*/

function onceRun(options){
	/*
		功能：
		默认24小时执行一次回调方法，可以根据自己配置时间
		参数:
		callBack:(fn||str) 按设置时间范围内执行一次
		选项：
		cookieName:(str) 分配cookie的名称，默认为 openAd
		value:(str) cookie记忆的值，默认为执行时间 t的值
		t:(int) 执行的时间范围，默认为24小时
		使用示例：
		onceRun({callBack:ad});
		function ad(){
			alert("弹出窗口");
		}
	*/
	
	var cookieName=options.cookieName||'openAd';
	var t=options.t||24;
	var value=options.value||t;
	var callBack=options.callBack;
	
	if(getCookie(cookieName)==null){
		if(typeof(callBack)=="string"){
		eval(callBack);
		}else{
		callBack();
		}
		setCookie(cookieName,value,t);
	}
}


function dialog(options){
	//功能：
	//弹出对话框，默认居中
	$.getScript(stx+'/js/jquery/dialog/dialog.js',function(){
		dialog(options);			   
	});
}
function blockUI(options){			//锁屏
	/*
		功能：锁屏
		参数：
		bg:(boolean) 锁屏时是否存在背景颜色，默认true为引用cls中的背景颜色，传false时，为透明白色，即锁屏不存在任何背景颜色
		使用示例：
		blockUI();
	*/
 	var defaults={
			 bg:true
	};
	var settings=$.extend(defaults,options);
	var bg=settings.bg;
	var bgColor="";
	var _h=$("html").height();
	
	if(!bg){var bgColor='style="background:#fff;opacity:0;filter:alpha(opacity=0);height:'+_h+'px;"';}
	if($("body").find(".filter").length==0)$("body").append('<div class="filter" '+bgColor+'><iframe></iframe></div>');
	
	
}

function unblockUI(){					//解屏
	$(".filter + div").remove();
	$(".filter").remove();
}


function verifyInput(options) {
	 
	/*
	功能：
	通用表单检验入口，主要遍历表单中的控件对象，然后通过调用 inputCheck() 进行校验
	参数：
	formId:(str) 表单对象 ID ，一般用于提交按钮位于表单以外的时候需要传该对像
	obj:(obj)当前校验控件对象，通常为this
	sendText:(str)加载中时，提交按钮的文字内容
	sendCls:(str)加载中按钮调用的样式名，默认在原基础样式名上加 _send,如  原为：class="btn1" ,则在后面加 class="btn1 btn1_send"
	控件 parameter 属性参数：
	type:(str) 校验类型，类型包括：select(为模拟select控件校验)，mobile(移动手机),tel(固话),str(字符串),en(英文，可含数字),date(日期),cn(中文),mail(电子邮箱),url(网址），path(目录路径)，idCard(身份证),num(整数),str(字符串),decimal(小数)
	value:(str)控件默认显示value值，默认为空
	minLen:(int)最少输入字符长度
	maxLen:(int)最大输入字符长度
	callTips:(fn)检验失败或成功后的提示函数，默认 inputTips();
	callBack:(fn)校验通过后的回调函数
	
	使用示例：
            <form action="#" method="post" name="charge" id="charge" />
            <ul>
            	<li><input type="text" class="input1"  value="要充值的手机号码"  onfocus="verifyInput({obj:this});" parameter="{type:'mobile',text:'要充值的手机号码'}"/></li>
                <li><input type="text" class="input1" value="充值小数10-500元"   onfocus="verifyInput({obj:this});" parameter="{type:'num',text:'充值小数10-500元'}"/></li>
                <li><button class="btn4" type="button" onclick="alert(verifyInput({obj:this,sendText:'正在处理'}));">充 值</button></li>
            </ul>
            </form>
	*/
	//alert(obj.type);	
	var formId = options.formId;
	var obj = options.obj;
	var sendText = options.sendText;
	var sendCls = options.sendCls;
	var callBack = options.callBack;
	var defaultTipsFn = inputTips;		//默认提示方法
 	if (obj.type == "button" || obj.type == "submit") {		//如果控件为button或submit 对象即校验遍历校验整个表单
		var sendBtn = obj;
		if (formId != undefined) {
			obj = $("#"+formId)[0];
		} else {
			obj = obj.form;
		}
		
		for (var i=0; i<obj.length; i++) {		//遍历form表单中含有parameter参数的控件
			//var parameter=obj[i].getAttribute("parameter");
			if (!$(obj[i]).attr('disabled')) {		//如果控件disabled为true,则不进行任何校验
				var parameter = evalJSON($(obj[i]).attr("parameter"));
				if (obj[i].type != 'checkbox' && obj[i].type != 'radio' && obj[i].tagName != 'SELECT') {		//过滤非输入类型的控件
					var callTips;
					var tipsText;
					if (parameter != null && parameter != "") {		//过滤不存在parameter或parameter参数为空的控件
						callTips = parameter.callTips || defaultTipsFn;		//为本类型控件设置默认的提示显示回调方法	inputTips
						tipsText = parameter.tipsText;		//为本类型控件设置默认的提示显示回调方法	inputTips
						if (obj[i].tagName == "TEXTAREA") callTips = parameter.callTips || defaultTipsFn;		//如果为textaraa类型控件，即默认为inputTips
						var _type;
						if (parameter.type != undefined) {		//如果校验类型不为空
							if (parameter.beforeCheck != undefined) {	//如果参数存在校验前的执行函数
								if (typeof(parameter.beforeCheck) == "string") {//如果执行函数为字符号
									eval(parameter.beforeCheck);
								} else {
									if (parameter.beforeCheck != undefined) parameter.beforeCheck();
								}
							}
							_type = parameter.type;
						} else {
							_type = "";		//如果不存在 type 的属性，则默认为 type="";
						}
						if (!inputCheck({obj:obj[i], type:parameter.type, callTips:callTips, minLen:parameter.minLen, maxLen:parameter.maxLen, conf:parameter.conf, need:parameter.need, tipsText:parameter.tipsText}));//return false;
					}
				}
				
				if (obj[i].type == "radio") {		//如果控件为radio
					var _obj = obj[i].name;				//取得radio 控件名称
					if ($(":radio[name='"+_obj+"']").eq(0).attr("parameter") != undefined) {//如果控件存在参数属性，通常本类型参数只有一个，提示显示回调方法
						var parameter = evalJSON($(":radio[name='"+_obj+"']").eq(0).attr("parameter"));
						if (parameter.beforeCheck != undefined) {	//如果参数存在校验前的执行函数
							if(typeof(parameter.beforeCheck) == "string") {//如果执行函数为字符号
								eval(parameter.beforeCheck);
							} else {	
								if (parameter.beforeCheck != undefined) parameter.beforeCheck();	
							}
						}
						
						callTips = callTips || defaultTipsFn;							//为本类型控件设置默认的提示显示回调方法	inputTips
						
						if (!_radioCheck(obj, _obj)) {
							callTips({obj:$(obj[i]), status:false, tipsText:tipsText});	//如果校验失败，则调用提示显示函数，false为失败参数		inputTips
							//return false;
						} else {
							callTips({obj:$(obj[i]), status:true, tipsText:tipsText});	//如果校验失败，true为失败参数		inputTips
						}
					}
				}
				
				if (obj[i].type == "checkbox") {		//如果控件为或checkbox
					parameter = evalJSON($(obj[i]).attr("parameter"));
					if (parameter != null) {	//如果checkbox的parameter属性不为空
						if (parameter.beforeCheck != undefined) {	//如果参数存在校验前的执行函数
							if (typeof(parameter.beforeCheck) == "string") {//如果执行函数为字符号
								eval(parameter.beforeCheck);
							} else {	
								if (parameter.beforeCheck != undefined) parameter.beforeCheck();	
							}
						}
						
						callTips = parameter.callTips;		//如果控件存在参数属性，通常本类型参数只有一个，提示显示回调方法
						callTips = callTips || defaultTipsFn;	
						var tipsText = parameter.tipsText;
						var n = 0;
						var text = "";
						
						$("input:checkbox[name='"+obj[i].name+"']").each(function(_i) {
							if ($(this)[0].checked) n += 1;
							//if($(this).attr("checked")==true||$(this).attr("checked")=='checked')n+=1;
						});
						var _min = parameter.minLen;
						var _max = parameter.maxLen;
						//alert($("input:checkbox[name='"+obj[i].name+"']").length);
						
						if (parameter.need) _min = _min || 1;
						_max = _max || $("input:checkbox[name='"+obj[i].name+"']").length;
						
						if (_min>n || _max<n) {		//如果n小于指定小于，及最大选中值，即不通过
							//callTips($(obj[i]),false,text,tipsText);	//如果校验失败，则调用提示显示函数，false为失败参数		inputTips
							
							if (typeof(callTips) == "string") {//如果回调方法传入为字符串类型
								eval(callTips)({obj:$(obj[i]), status:false, text:text, tipsText:tipsText});	//如果校验失败，则调用提示显示函数，false为失败参数		inputTips
							} else {
								//callTips($(obj[i]),false,text,tipsText);	//如果校验失败，则调用提示显示函数，false为失败参数		inputTips
								callTips({obj:$(obj[i]), status:false, text:text, tipsText:tipsText});	//如果校验失败，则调用提示显示函数，false为失败参数		inputTips
							};
							//return false;
						} else {	//否则通过
							//callTips($(obj[i]),true,text,tipsText);	//如果校验失败，则调用提示显示函数，false为失败参数		inputTips
							if (typeof(callTips) == "string") {//如果回调方法传入为字符串类型
								//	eval(callTips)($(obj[i]),true,text,tipsText);	
								eval(callTips)({obj:$(obj[i]),status:true,text:text,tipsText:tipsText});	//如果校验失败，则调用提示显示函数，false为失败参数		inputTips
							} else {
							//	callTips($(obj[i]),true,text,tipsText);	//如果校验失败，则调用提示显示函数，false为失败参数		inputTips
								callTips({obj:$(obj[i]),status:true,text:text,tipsText:tipsText});	//如果校验失败，则调用提示显示函数，false为失败参数		inputTips
							};
						}
					};
				}
				
				if (obj[i].tagName == 'SELECT') {
					parameter = evalJSON($(obj[i]).attr("parameter"));
					if (parameter != null) {
						if (parameter.beforeCheck != undefined) {	//如果参数存在校验前的执行函数
							if (typeof(parameter.beforeCheck) == "string") {//如果执行函数为字符号
								eval(parameter.beforeCheck);
							} else {
								if (parameter.beforeCheck != undefined) parameter.beforeCheck();	
							}
						}
						
						callTips = parameter.callTips;		//如果控件存在参数属性，通常本类型参数只有一个，提示显示回调方法
						callTips = callTips || defaultTipsFn;										//为本类型控件设置默认的提示显示回调方法
						var tipsText = parameter.tipsText || "";
						var text = "";
						
						if ($(obj[i]).val() == "") {
							//callTips($(obj[i]),false,text,parameter.tipsText);	//如果校验失败，则调用提示显示函数，false为失败参数
							if(typeof(callTips)=="string"){//如果回调方法传入为字符串类型
								//eval(callTips)($(obj[i]),false,text,tipsText);	//如果校验失败，则调用提示显示函数，false为失败参数
								eval(callTips)({obj:$(obj[i]),status:false,text:text,tipsText:tipsText});	//如果校验失败，则调用提示显示函数，false为失败参数		inputTips
							} else {
								//	callTips($(obj[i]),false,text,tipsText);	//如果校验失败，则调用提示显示函数，false为失败参数
								callTips({obj:$(obj[i]),status:false,text:text,tipsText:tipsText});	//如果校验失败，则调用提示显示函数，false为失败参数		inputTips
							};
							//return false;		//如果select控件值为空
						} else {
							//callTips($(obj[i]),true,text,parameter.tipsText);	//如果校验通过，则调用提示显示函数,true为成功参数
							if (typeof(callTips) == "string") {//如果回调方法传入为字符串类型
								//eval(callTips)($(obj[i]),true,text,tipsText);	//如果校验通过，则调用提示显示函数,true为成功参数
								eval(callTips)({obj:$(obj[i]),status:true,text:text,tipsText:tipsText});	//如果校验失败，则调用提示显示函数，true为失败参数		inputTips
							} else {
								//callTips($(obj[i]),true,text,tipsText);	//如果校验通过，则调用提示显示函数,true为成功参数
								callTips({obj:$(obj[i]),status:true,text:text,tipsText:tipsText});	//如果校验失败，则调用提示显示函数，true为失败参数		inputTips
							};
						}
					}
				}
			}
		}
		//如果校验通过往下执行
		
		if (callBack != undefined) callBack();		//如果存在
			
		return formProcess({sendBtn:sendBtn,formId:formId,sendText:sendText,sendCls:sendCls,lock:true});		//执行表单控件锁定,可能这里要改为锁屏，待优化
	} else {		//否则单个控件对象
		blurCheck(obj);			//调用控件失焦后的校验方法
	}
}

function blurCheck(obj){
	 
	/*
	功能：
	控件焦点离开时对象校验入口，这个方法通常是内部调用，入口为 verifyInput()
	参数：
	obj:当前校验控件对象，通常为this
	控件 parameter 属性参数：
	type:(str) 校验类型，类型包括：select(为模拟select控件校验)，mobile(移动手机),tel(固话),str(字符串),en(英文，可含数字),date(日期),cn(中文),mail(电子邮箱),url(网址），path(目录路径)，idCard(身份证),num(整数),str(字符串),decimal(小数)
	value:控件默认显示value值，默认为空
	tipsText:控件提示语句，默认为空
	minLen:最少输入字符长度
	maxLen:最大输入字符长度
	callTips:检验失败或成功后的提示函数，默认 inputTips()，如果为textarea类型控件默认为inputTips();
	txtCount:(boolean) 用于editor校验类型，动态显示已输入内容长度
	使用示例：
    <input type="text"   value="要充值的手机号码"  onfocus="blurCheck(this);"  parameter="{type:'mobile',text:'要充值的手机号码'}"/>
	*/
	
	var parameter = evalJSON($(obj).attr("parameter"));		//转换控件参数字符串为JSON对象
	var type = parameter.type;
	var value = parameter.value;
	var tipsText = parameter.tipsText;
	var minLen = parameter.minLen;		
	var maxLen = parameter.maxLen;
	var conf = parameter.conf;
	var need = parameter.need;
	var txtCount = parameter.txtCount;

	var callTips = parameter.callTips || inputTips;
//	if(obj.tagName=="TEXTAREA")callTips=parameter.callTips||inputTips;
	/*$(obj).blur(function(){//对象失焦
			inputCheck({obj:obj,type:type,minLen:minLen,maxLen:maxLen,callTips:callTips,conf:conf,need:need,tipsText:tipsText});		//调用控件检验方法			 
			
	});
	*/
	$(obj).one('blur', function() {
		if (parameter.beforeCheck != undefined) {	//如果参数存在校验前的执行函数
			if (typeof(parameter.beforeCheck) == "string") {//如果执行函数为字符号
				eval(parameter.beforeCheck);
			} else {	
				if (parameter.beforeCheck != undefined) parameter.beforeCheck();	
			}
		}
		
		$(obj).parents('form').find('.inputTips').remove();		//焦点离开后，即把表单中的提示层清除
		inputCheck({obj:obj, type:type, minLen:minLen, maxLen:maxLen, callTips:callTips, conf:conf, need:need, tipsText:tipsText, txtCount:txtCount});		//调用控件检验方法	
	});
}

function inputCheck(options){
	/*
	功能：
	表单控件校验，内部方法，通过类型(type)定义 checkRex() 返回正则表达式进行校验判断，主要为接口 verifyInput()方法校验表单对象
	参数：
	obj:(obj)控件对象
	type:(str) 校验类型，类型包括：select(为模拟select控件校验)，mobile(移动手机),tel(固话),str(字符串),en(英文，可含数字),date(日期),cn(中文),mail(电子邮箱),url(网址），path(目录路径)，idCard(身份证),num(整数),str(字符串),decimal(小数)
	minLen:(int)字符最少值
	maxLen:(int)字符最大值
	callTips:(fn)检验失败或成功后的提示函数，默认 inputTips();
	conf:(str)一般为确认密码时使用，值对为要确认控件的名称(name)
	need:(boolean) 是否为必填字段，默认为false 非必填，即空值时不校验，非空值时校验，true为必填
	tipsText:(str)校验信息提示字符串，默认为空
	txtCount:(boolean) 用于editor校验类型，动态显示已输入内容长度
	使用示例：
	<input type="text" id="inputId" value="请输入手机号码"/>
	inputCheck({obj:$("inputId"),type:'num'});
	*/
	
	
	var defaults = {	//默认值
		type : '',			//类型默认空，即任意
		need : false 			//默认为非必填
	}
	var settings = $.extend(defaults, options);	
	
	var obj = settings.obj;
	var type = settings.type;
	var text = settings.value;
	var tipsText = settings.tipsText;
	var callTips = settings.callTips;
	var conf = settings.conf;
	var need = settings.need;
	var txtCount = settings.txtCount;
	
	var minLen = settings.minLen;
	var maxLen = settings.maxLen;
	
	if (maxLen == undefined) maxLen = $(obj).attr("maxlength");	//如果控件parameter参数中不存maxLen 则获取控件中的 maxlength 值
	if (minLen == undefined) minLen = $(obj).attr("minlength");	//如果控件parameter参数中不存minLen 则获取控件中的 minlength 值

	//alert(conf);
	if (conf != undefined) {	//如果为校验重复确认类型
		 
		if ($(obj).val() == $("input[name='"+conf+"']").eq(0).val() && $(obj).val() != "") {	//如果确认值一致，即通过
			//callTips(obj,true,text);	//调用提示状态提示
			var _par = evalJSON($("input[name='"+conf+"']").eq(0).attr("parameter"));
			var _type = _par.type;
			if (_type == undefined) _type = 'str';
			var _rex = checkRex(_type, _par.minLen, _par.maxLen);	//返回正则表达式
			
			if (!_rex.test($(obj).val())) {
				if (typeof(callTips) == "string") {//如果回调方法传入为字符串类型
					//eval(callTips)(obj,false,text,tipsText);
					eval(callTips)({obj:obj,status:false,text:text,tipsText:tipsText});
				} else {
					//callTips(obj,false,text,tipsText);	//调用提示状态提示
					callTips({obj:obj,status:false,text:text,tipsText:tipsText});
				};
				return false;
			}
				
			if (typeof(callTips) == "string") {//如果回调方法传入为字符串类型
				//eval(callTips)(obj,true,text,tipsText);
				eval(callTips)({obj:obj,status:true,text:text,tipsText:tipsText});
			} else {
				//callTips(obj,true,text,tipsText);	//调用提示状态提示
				callTips({obj:obj,status:true,text:text,tipsText:tipsText});
			};
			return true;				//不通过返回true
		} else {	//否则
			//callTips(obj,false,text);	//调用提示状态提示
			if (typeof(callTips) == "string") {//如果回调方法传入为字符串类型
				//eval(callTips)(obj,false,text,tipsText);
				eval(callTips)({obj:obj,status:false,text:text,tipsText:tipsText});
			} else {
				//callTips(obj,false,text,tipsText);	//调用提示状态提示
				callTips({obj:obj,status:false,text:text,tipsText:tipsText});
			};
			return false;				//不通过返回false
		};
	} else {
		 
		if (type == "select") {
			need = true;		//如果下拉列表，即默认为为必选
			if ($(obj).parents("span").find("input:checked").length > 0) {		//这里的校验主要是针对模拟控件中为多选项设置
				return true;
			}
			type = "";
		}
		
		if (need == false)
			if ($(obj).val() == "") {
				$(obj).parent().find('.inputErr').remove();		//如果当前对象中的父标签存在错误提示，即删除
				return true;		//如果need为false，即为非必填，控件值为空即通过，不进行校验，如果非空值时，即继续往下校验
			}
			
		if (type == "idCard") type = $(obj).val().length <= 15 ? "idCard1" : "idCard2";		//如果为15位身份证即type为idCard1,否则为18位，身份证类型为idCard2
		var rex = checkRex(type, minLen, maxLen);	//返回正则表达式
		
		if ($(obj).val() != text) {			//如果控件对象输入内容不是默认值
			 
			if (rex != "") {
				if (!rex.test($(obj).val())) { //校验不通过
					if (callTips != undefined) {		//如果没有传入指定的提示方法
						if (typeof(callTips) == "string") {//如果回调方法传入为字符串类型
							//eval(callTips)(obj,false,text,tipsText);
							eval(callTips)({obj:obj, status:false, text:text, tipsText:tipsText});
						} else {
							//callTips(obj,false,text,tipsText);	//调用提示状态提示
							callTips({obj:obj, status:false, text:text, tipsText:tipsText});	//调用提示状态提示
						};
						return false;
					}
					return false;				//不通过返回false
				} else {		//校验通过
					if (callTips != undefined) {			//如果没有传入指定的提示方法
						//	callTips(obj,true,text);	//调用提示状态提示
						if (typeof(callTips) == "string") {//如果回调方法传入为字符串类型
							//eval(callTips)(obj,true,text,tipsText);
							eval(callTips)({obj:obj, status:true, text:text, tipsText:tipsText});
						} else {
							//callTips(obj,true,text,tipsText);	//调用提示状态提示
							callTips({obj:obj, status:true, text:text, tipsText:tipsText});	//调用提示状态提示
						};
					} else {
						//alert("校验成功");			//即直接通过alert输出结果
					}
					return true;				//通过返回true
				};
			} else {
				if ($(obj).val() == "") {
					if (typeof(callTips) == "string") {//如果回调方法传入为字符串类型
						//eval(callTips)(obj,false,text,tipsText);
						eval(callTips)({obj:obj,status:false,text:text,tipsText:tipsText});
					} else {
						//callTips(obj,false,text,tipsText);	//调用提示状态提示
						callTips({obj:obj,status:false,text:text,tipsText:tipsText});	//调用提示状态提示
					};
					return false;				//不通过返回false
				} else {
					if (type == 'editor') {
						var len = getEditorStringLength($(obj).val());
						if (len > maxLen) {
							if (typeof(callTips) == "string") {//如果回调方法传入为字符串类型
								//eval(callTips)(obj,true,text,tipsText);
								eval(callTips)({obj:obj,status:false,text:text,tipsText:tipsText});
							} else {
								//callTips(obj,true,text,tipsText);	//调用提示状态提示
								callTips({obj:obj,status:false,text:text,tipsText:tipsText});	//调用提示状态提示
							};
							return false;
						}
					}
					if ($(obj).val().length < minLen || $(obj).val().length > maxLen) {
						if (typeof(callTips) == "string") {//如果回调方法传入为字符串类型
							//eval(callTips)(obj,true,text,tipsText);
							eval(callTips)({obj:obj,status:false,text:text,tipsText:tipsText});
						} else {
							//callTips(obj,true,text,tipsText);	//调用提示状态提示
							callTips({obj:obj,status:false,text:text,tipsText:tipsText});	//调用提示状态提示
						};
						return false;				//不通过返回false
					} else {
						if (typeof(callTips) == "string") {//如果回调方法传入为字符串类型
							//eval(callTips)(obj,true,text,tipsText);
							eval(callTips)({obj:obj,status:true,text:text,tipsText:tipsText});
						} else {
							//callTips(obj,true,text,tipsText);	//调用提示状态提示
							callTips({obj:obj,status:true,text:text,tipsText:tipsText});	//调用提示状态提示
						};
						return true;				//通过返回true
					}
				}
			}
		}
	}
}
	
function _radioCheck(obj,_obj){
	/*
	功能：
	radio,checkbox控件校验，内部方法，主要配合 verifyInput() 表单校验入口使用，属于内部函数
	参数：
	obj:为表单对象
	_obj:为控件对象
	*/
 		var _obj=$(obj).find('input[name="'+_obj+'"]');
		if(!_checkObjs(_obj)){
		  return false;
		}
	  return true;
	}

function _checkObjs(_obj){
	/*
	功能：
	radio,checkbox控件校验，内部方法，主要配合 _radioCheck() ，属于内部函数
	参数：
	_obj:为控件对象
	*/
  for(var i=0;i<_obj.length;i++){
 	if(_obj[i].checked)return true;
  }
  return false;
}


function checkRex(type, minLen, maxLen) {
	/*
	功能：
	返回正则表达式，主要提供给inputCheck()使用，属于内部函数
	返回值：
	根据type的类型返回正式的表达式
	参数：
	type:(str) 校验类型，类型包括：select(为模拟select控件校验)，mobile(移动手机),tel(固话),str(字符串),en(英文，可含数字),date(日期),cn(中文),mail(电子邮箱),url(网址），path(目录路径)，idCard(身份证),num(整数),str(字符串),decimal(小数)
	minLen:字符最少值
	maxLen:字符最大值
	*/
	var type;
	var minLen = minLen || 1;
	var maxLen = maxLen;
		
	type = type == 'select' ? 'str' : type;		//如果类型为select即默认为str
	
	switch (type) {
		case 'mobile':	 //正则表达式的判断移动手机字段及位数   13800138000
			type = /^1(34|35|36|37|38|39|58|59|50|51|52|57|87|47|88|82|83)[0-9]{8}$/;	//正则表达式的判断手机字段及位数
			break;
		case 'tel':		//正则表达式的判断电话号码格式   020-88888888
			type = /^([0-9]{4}-[0-9]{8})$|^([0-9]{3}-[0-9]{8})$|^([0-9]{4}-[0-9]{7})$|^[0-9]{7}$/;  	
			break;
		case 'str':		//正则表达式的判断是否 中文（A-Z a-z 0-9 - _ .
			if (maxLen == undefined) {	//如果不存在maxLen参数
				type = eval('/^[\u0391-\uFFE5-\A-Za-z0-9_ \\-\/]{'+minLen+',}$/');   	
			} else {
				type = eval('/^[\u0391-\uFFE5-\A-Za-z0-9_ \\-\/]{'+minLen+','+maxLen+'}$/');
			}
			break;
		case 'en':		//正则表达式英文数字加字母
			if (maxLen == undefined) {	//如果不存在maxLen参数
				type = eval('/^\s*[.A-Za-z0-9_-]{'+minLen+',}\s*$/'); 
			} else {
				type = eval('/^\s*[.A-Za-z0-9_-]{'+minLen+','+maxLen+'}\s*$/'); 
			}
			break;
		case 'cn':		//正则表达式的判断是否是中文  张三
			if (maxLen == undefined) {	//如果不存在maxLen参数
				type = eval('/^[\u0391-\uFFE5]{'+minLen+',}$/'); 
			} else {
				type = eval('/^[\u0391-\uFFE5]{'+minLen+','+maxLen+'}$/'); 
			}
			break;
		case 'mail':	//正则表达式的判断EMAIL   abcd@10086.cn
			type = /^([-_A-Za-z0-9\.]+)@([_A-Za-z0-9]+\.)+[A-Za-z0-9]{2,3}$/; 
			break;
		case 'url':		//正则表达式的判断URL  http://gd.10086.cn
			//type = /^(?:(?:http[s]?|ftp):\/\/|/)[^\/\.]+?\..+\w$/;	
			type = /(?:^(?:https|http|ftp):\/\/[^\/\.]+?\..+)|(?:^\/.+)/; //增加以根目录开始的URL支持：'/...', 见JIRA： NEWADMINTEST-377
			break;
		case 'path':		//待增加
			type = '';
			break;
		case 'idCard1':			//15位身份证号码正则表达式
			type = /^[1-9]\d{7}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{3}$/; 
			break;
		case 'date':			//日期 2010-10-10
			type = /^[1-2][0|9]\d\d-[0-1]\d-[0-3]\d+$/;
			break;
		case 'idCard2':		//18位身份证号码正则表达式
			type=/^[1-9]\d{5}[1-9]\d{3}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])((\d{4})|\d{3}[A-Z])$/;
			break;
		case 'num':		//正则表达式的判断手机字段及位数  3423
			if (maxLen == undefined) {	//如果不存在maxLen参数
				type = eval('/^[0-9]{'+minLen+',}$/');		
			} else {
				type = eval('/^[0-9]{'+minLen+','+maxLen+'}$/');		
			}
			break;
		case 'decimal':		//正则表达式的判断小数，可以有小数也可以没有小数，包括正数、负数和0
			//type=eval('/^(-)?(([1-9]{'+minLen+','+maxLen+'})|([0]{9}))(\\.(\\d){1,3})?$/');	
			type = /^(-)?(([0-9]{1}\d*)|([0]{9}))(\.(\d){1,3})?$/;		
			break;
		case 'editor':  //对editor类型的输入不做限制
		case '':
			type = '';
			break;
		default:		//如果不存在预设类型的正式表达式，则默认为返回传入值，通常用于自定义正式表达式
			type = eval(type);		
			break;
	}
	return type;
}

function getEditorStringLength(val) {
	var len = val.length;
	var regexp = /[^\x00-\xff]+/g;
	var result = val.match(regexp);
	if (result != null) {
		for (var i=0; i<result.length; i++) {
			len += result[i].length * 2;
		}
    }
	return len;
}

function focusTips(obj){		
	/*功能:
	为控件绑定焦点事件，主要为控件输入提示提供接口，现主要提供于verifyForm()使用
	参数：
	obj:(obj)为表单提交按钮的ID
	*/
	var form=obj[0];
	var obj=form.elements;
	
 	for(var i=0;i<obj.length;i++){
 		if($(obj[i]).attr("type")=="text"||$(obj[i]).attr("type")=="password"||obj[i].tagName=="TEXTAREA"){
			$(obj[i]).bind('focus',function(){
 					inputTipsText({obj:$(this)});
			}).blur(function(){
					inputTipsText({obj:$(this)});
			});
 		}	
 	}
}

function focusLight(obj){
	/*
	功能：
	控件获得焦点后样式改变
	参数：
	obj:当前控件对象，通常用this
	控件 parameter 属性参数：
	value:控件的默认value值
	cls:控件获得焦点时的样式名，默认为 input_focus
	使用示例：
       <input type="text" value="限广东地区移动号码" onfocus="focusLight(this);" parameter="{text:'限广东地区移动号码'}"/>
	*/

 	var cls;
	var clsOld;
	var text;
	//var value;
	var parameter = evalJSON($(obj).attr("parameter"));		//转换控件参数字符串为JSON对象
	if (parameter != null) {
		cls = parameter.cls;
	 	clsOld = $(obj).attr("class");		//缓存旧样式
		// value=parameter.value;
	}
	
	cls = cls || "input1_focus";		//默认焦点样式 
	
	$(obj).addClass(obj.className+" "+cls);	//增加焦点样式 
	
	if ($(obj).parent().find(".inputErr").length > 0) {
		$(obj).parents("form").find(".input2_focus").removeClass("input2_focus");
		$(obj).addClass("input2_focus");	
	}
	
	if($(obj).hasClass("inputErr")){
		$(obj).removeClass("input1_focus").addClass("input2_focus");	
	}
	
	$(obj).one('blur', function() {//对象失焦
		//if($(obj).val()=="")$(obj).val($(obj).attr("_value"));	//如果控件没有输入任何内容，即恢复默认值
		$(obj).parents("form").find(".input2_focus").removeClass("input2_focus");
		$(obj).removeClass(cls).css("color", "");		//删除焦点样式 
			
		if ($(obj).hasClass("inputErr")) {
			$(obj).removeClass("input2_focus");	
		}
	});
}



function focusLight_bak(obj){
	/*
	功能：
	控件获得焦点后样式改变
	参数：
	obj:当前控件对象，通常用this
	控件 parameter 属性参数：
	text:控件的默认value值
	cls:控件获得焦点时的样式名，默认为 input_focus
	使用示例：
       <input type="text" value="限广东地区移动号码" onfocus="focusLight(this);" parameter="{text:'限广东地区移动号码'}"/>
	*/

 	var cls;
	var clsOld;
	var text;
	
	var parameter=evalJSON($(obj).attr("parameter"));		//转换控件参数字符串为JSON对象
	if(parameter!=null){
	 cls=parameter.cls;
	 clsOld=$(obj).attr("class");		//缓存旧样式
	 text=parameter.text;
	}
	
	cls=cls||"input1_focus";		//默认焦点样式 
	
	
	 if(text!=undefined){
		 $(obj).addClass(cls).css("color","#555");
 		if($(obj).val()==text)$(obj).val("");			//获得焦点后，如果对象value与传入值一致,如果有默认值传入
		$(obj).one('blur',function(){	//对象失焦
				if(obj.value==""||obj.value==text){		//如果对象value值为空，或value值为传入值
					$(obj).css("color","").removeClass(cls).val(text); //删除焦点样式 //恢复默认value值
 				}else if(obj.value!=text){		//否则，即内容为已输入，恢复原始样式，但文字颜色改变
					$(obj).css("color","#555").removeClass(cls); 		//#555为规范中的默认颜色 //删除焦点样式 
 				}
		});
		
	 }else{
		$(obj).addClass(obj.className+" "+cls).css("color","#555");	//增加焦点样式 
		
		if($(obj).parent().find(".inputErr").length>0){
			$(obj).parents("form").find(".input2_focus").removeClass("input2_focus");
			$(obj).addClass("input2_focus");	
		}
		
		if($(obj).hasClass("inputErr")){
			$(obj).removeClass("input1_focus").addClass("input2_focus");	
		}
		
		
		$(obj).one('blur',function(){//对象失焦
				$(obj).parents("form").find(".input2_focus").removeClass("input2_focus");
				$(obj).removeClass(cls).css("color","#555");		//删除焦点样式 
				
			if($(obj).hasClass("inputErr")){
				$(obj).removeClass("input2_focus");	
			}
		});
		
	 }
}


var formProcessxxxx;	//定义一个全局变量，用于备份提交按钮原始文字内容，以便恢复
var formProcessxxxxx;	//定义一个全局变量，用于备份提交按钮原始样式，以便恢复
function formProcess(options){
	/*
	功能：
	表单提交时表单控件锁定，及解除锁定
	参数：
	formId:(str) 表单对象 ID ，一般用于提交按钮位于表单以外的时候需要传该对像
	sendBtn:(obj) 按钮对象
 	sendText:(str) 按钮按下提交时显示的文字
	sendCls:(str)提交按钮样式，默认为原样式后加  _send，如原按钮样式名为 btn1,则默认提交时的追加样式为 btn1_send，如存在传入样式名，即以传入样式为准
	lock:(boolean) 提交是否锁定所有控件，不传任何值，提交表单时不锁定表单控件，传true 为锁定,false为解锁解锁定表单控件，false此种情况，主要用于服务端校验失败等原因时调用，解除表单
	使用示例：
	*/
	var formId = options.formId;
	var btn = options.sendBtn;
	var sendText = options.sendText;
	var lock = options.lock;
	var sendCls = options.sendCls;
	var btnTagName = $(btn).attr("tagName");
	var f;
	if (formId != undefined) {
		f = $("#"+formId);
	} else {
		f = $(btn).parents("form");
	}
	
	if (lock != false) {						//如果存在lock锁定参数为true
	
	if (f.find(".inputErr").length == 0) {	//如果控件错误提示为0个，即返回true
		//blockUI({bg:false});				//无背景锁屏
		if (sendText != undefined) {
			if (btnTagName == 'BUTTON') {		//考虑firefox不支持button value值问题
				formProcessxxxx = $(btn).html();
				$(btn).html(sendText);		//如果存在加载中的指定文字，即显示
			} else {
				formProcessxxxx = $(btn).val();
				$(btn).val(sendText);
			}
		}
		formProcessxxxxx = formProcessxxxxx ? formProcessxxxxx : $(btn).attr("class");	//备份旧样式
		
		if (sendCls == undefined && formProcessxxxxx) {				//如果不存在加载中的样式
			sendCls = formProcessxxxxx + "_send";
			$(btn).addClass(sendCls);
		} else if (sendCls) {
			$(btn).addClass(sendCls);
		}
		
		//$(btn).attr("disabled",true);		
		return true;
	} else {
		if (f.find(".inputErr:first").parent().find(":[parameter]").length < 2 && f.find(".inputErr:first").parent().find("input:[type='text']").length < 2) {	//如果控件父标签容器中不存在多个带校验参数的控件
			var _o = f.find(".inputErr:first").siblings(0);
			
			if(_o.attr("type")=="radio"||_o.attr("type")=="checkbox"){	//如果控件对象为radio 或checkbox
				_o=$(btn).parents("form").find(".inputErr:first").parent().children().eq(0);
				inputTipsText({obj:_o});
				return false;
			}
			if(f.find(".inputErr:first").attr('parameter')==undefined){	//如果对象不存在校验参数，即对象非控件，焦点则位到该标签中第一个控件中
				_o=f.find(".inputErr:first").siblings(0);
				_o.focus();	
				inputTipsText({obj:_o});
			}else{	//否则，对象为控件
				_o=f.find(".inputErr:first").focus();
			};
			
			
		}else{	//否则控件父标签容器中存在多个带校验参数的控件，则重新遍历该父标签中的控件对象，以确定为哪个校验不通，即把光标定位于该对象
			
		//	$(btn).parents("form").find(".inputErr:first").parent().children().eq(0).focus();
				
				var _o=f.find(".inputErr:first").parent().find(":[parameter]");
					for(var n=0;n<_o.length;n++){
						var _par=evalJSON(_o.eq(n).attr("parameter"));
						if(_o.eq(n).attr("parameter")!=undefined){
							// alert(_o.eq(n).attr("parameter"));
							 if(!inputCheck({obj:$(_o.eq(n)),type:_par.type,minLen:_par.minLen,maxLen:_par.maxLen})){
								
  								$(_o.eq(n)).focus();
								inputTipsText({obj:$(_o.eq(n))});
								return false;
							 }
							//alert(_o.eq(n).val());	
						}
					}
				
				
		};
		
		return false;
		}
		
	}else{	//校验不通过
		
			//$(btn).parents("form").find(".inputErr:fisrt").siblings(0).focus();
		//	$(btn).parents("form").find(".inputErr:first").parent().children(0).focus();		//第一个带错误提示的控件获取焦点
		//alert($(btn).parents("form").find(".inputErr:first").siblings(0).attr("name"));
			
			
			
			$(btn).parents("form").find(".inputErr:first").siblings(0).focus();	
			
		
			if(btnTagName=='BUTTON'){		//考虑firefox不支持button value值问题
			//formProcessxxxx=$(btn).html();
			$(btn).html(formProcessxxxx);		//如果存在加载中的指定文字，即显示
			}else{
			//formProcessxxxx=$(btn).val();	
			$(btn).val(formProcessxxxx);
			}
		//	btn.disabled=false;	//按钮解锁
			//$(btn).attr("disabled",false)
			$(btn).removeClass().addClass(formProcessxxxxx);	//先删除原样式 ,并进行恢复旧样式
			
		//	unblockUI();	//解屏
			return false;
	}
	

	
}
 	 




	/*
function dynIframeSize(id) { 

	功能：
	iframe自适应页面 
	参数：
	id:iframe对象id
	使用示例：
	<iframe src ="tt.shtml" frameborder="0" scrolling="auto" id="ifm"  onload="dyniframesize('ifm');" ></iframe> 
	
	var pTar = null; 
	if (document.getElementById){ 
	pTar =$("#"+id); 
	} 
	else{ 
	eval('pTar = ' + id + ';'); 
	} 
	
	if (pTar && !window.opera){ 
	
 	pTar.style.display="block" 
	if (pTar.contentDocument && pTar.contentDocument.body.offsetHeight){ 
 	pTar.height = pTar.contentDocument.body.offsetHeight +20; 
	pTar.width = pTar.contentDocument.body.scrollWidth+20; 
	} 
	else if (pTar.Document && pTar.Document.body.scrollHeight){ 
 	pTar.height = pTar.Document.body.scrollHeight; 
	pTar.width = pTar.Document.body.scrollWidth; 
	} 
	} 
} 
	*/

/*
 * 功能 tab切换效果
 * 参数说明：
 * menuid为选项卡菜单容器id
 * conid为选项卡内容容器id
 * 约定：选项卡菜单由class='tabMenu-02'的标签包含着，menu 必须由li组成,内容必须由 class='tabColumn'的标签组成 内容标签是conid的子元素 html必须已经生成
 * 		默认高亮显示的菜单 li class='on' 默认不显示的内容必须隐藏 比如添加class='hide'
 * 示例：
 * html:<div class='tabMenu-02'><ul id='tabMenu'><li class='on'>tab菜单1</li><li>tab菜单2</li></ul></div>
 * 		<div id='tabCon'><div class='tabColumn'>tab内容1</div><div class='tabColumn hide'>tab内容2</div></div>
 * js:tabFunc("#tabMenu","#tabCon");
 */
function tabFunc(menuid,conid)
{
	var $menus = $(menuid+" li");
	var $cons = $(conid+" > .tabColumn");	
	
	$menus.click(function(){		
		$(this).addClass("on").siblings().removeClass("on");
		$cons.hide().eq($(this).index()).show();				
	});
}



function setCookie(sName,sValue,expireHours,path,domain,secure) { 
	/*
	功能：
	设置cookie 
	参数：
	sName:cookie名称
	sValue:cookie值
	expireHours:cookie的过期时间，单位为小时
	path:(str) 保存的路径，如： /shop  可不传
	domain:(str) 保存的域，指定可访问cookie的主机名，如 gd.10086.cn，可不传
	secure:(boolnea) 安全，默认为false，如果为true时cookie就只能通过https或其他安全协议才能传输
	
	使用示例：
	设置cookie内容：<input type="text" value="13800138000" id="pNum"/><button onclick="setCookie('pNum',$('#pNum').val(),1)">设置cookie</button><br/>
	清除cookie内容：
	<button  onclick="setCookie('pNum','',0)">清除cookie内容</button>
	*/
    var expDays = expireHours*24*60*60*1000; 
	var expDate = new Date(); 
	expDate.setTime(expDate.getTime()+expDays); 
	var expString = ((expireHours==null) ? "" : (";expires="+expDate.toGMTString()));
	var pathString = ((path==null) ? "" : (";path="+path));
	var domainString = ((domain==null) ? "" : (";domain="+domain));
	var secureString = ((secure==true) ? ";secure" : "" );

	document.cookie = sName + "=" + escape(sValue) + expString + pathString + domainString + secureString; 
	} 

function getCookie(sName) { 
	/*
	功能：
	获取cookie 
	参数：
	sName:cookie名称
	返回：
	sName的值
	使用示例：
	<button onclick="alert(getCookie('pNum'))">取出cookie</button>
	*/
var aCookie = document.cookie.split("; "); 
for (var j=0; j < aCookie.length; j++){ 
    var aCrumb = aCookie[j].split("="); 
    if (escape(sName) == aCrumb[0]) 
      return unescape(aCrumb[1]); 
} 
return null; 
} 



function evalJSON(strJson){
	/*
		功能：字符串转JSON数据
	*/
	 
   return eval( "(" + strJson + ")");
}
function strJSON(JsonObj){
	/*
		功能：JSON数据转字符串
	*/
  var S = [];
  for(var i in JsonObj){
	JsonObj[i] = typeof JsonObj[i] == 'string'?'\''+JsonObj[i]+'\'':(typeof JsonObj[i] == 'object'?OString(JsonObj[i]):JsonObj[i]);
	S.push(i+':'+JsonObj[i]); 
  }
	return '{'+S.join(',')+'}';
}

function dopop(options){
	var defaults={		
		//默认选项配置		
			id:'popBox',//弹出层ID 默认为popBox
			sub:'.pop',//弹出层二层选择器 默认为.pop
			title:"",//默认为空
        	tips:"",//（新增）概要提示 不指定该属性则显示'html'（默认）；指定该属性则显示'tips'，隐藏'html'并加'查看详细错误信息'链接
 			html:"",//弹出层主体内容 支持html [必需]
  			button:"",//弹出层按钮 支持html
  			isLock:true,//是否锁屏 默认锁屏
  			width:"max",//弹出层宽度 默认'max' 提供可选 大'max':640 中'mid':430 小'min':350 三种宽度 也可以自定义设置一个值 
			height:null,//弹出层高度 默认不设置
  			zIndex:100,//弹出层的优先级 值越大优先级越高 默认为100 后弹出的层优先
  			cover:self,//要遮盖的窗体 默认遮盖当前窗体 父窗体为top
  			isMsg:'',//是否为提示信息 默认为空 '' 提供可选 普通提示信息：'normal';错误提示信息：'error';成功提示信息：'success'
  			esckey:false,//是否开启按esckey则自动隐藏弹出层的功能，同时开启了点层外部则自动隐藏该层 默认不开启
  			drag:true,//可拖动 默认开启
  			dragHeadle:'.t',//拖动手柄 默认'.t' jquery选择器
  			closeBtnShow:true,//弹出层是否显示关闭按钮 默认显示
  			closeCallBack:function(){},//关闭后的回调函数 不能够是一条语句 如果要带参数closeCallBack:function(){你的函数名(你的参数);} 不带参数closeCallBack:你的函数名
  			closeTimeOut:0,//弹出层延时多少毫秒自动关闭 默认不关闭
  			isAnimate:true,//是否开启效果 默认开启
  			isCenter:true,//是否居中，默认居中
  			isHide:false, //是否要去除弹出层 默认不去除
			obj:$('body'), //需要定位loading状态层的容器 默认是当前body 【如果cover:top，则该参数无效】
			isbg:true,//遮罩层是否是灰色？默认是
			callBack:null//弹出层创建完毕的回调函数
			};
					
		
	if(options.isMsg!=undefined)
	{
		defaults.width = 'min';
		//defaults.isCenter = false;
	}			
	
	var settings = jQuery.extend({}, defaults, options);//合并defaults 和 options 不修改 defaults
	
	//弹出层的宽度
	var w = 0;

    //如果指定了概要提示，则弹出层宽度强制为 min，同时保存指定宽度值到 w2，以便在显示概要提示的时候使用
    if (settings.tips) {
        var initWidth = {"max" : 640, "mid" : 430, "min" : 350},
            w2 = settings.width;
        w2 = initWidth[w2] !== undefined ? initWidth[w2] : w2;

        settings.width = "min";
    }
	
	switch(settings.width)
	{
		case "max":
		w=640;
		break;
		case "mid":
		w=430;
		break;
		case "min":
		w=350;
		break;
		default:
		w=settings.width;
		break;
	}
	
	
	if(settings.isMsg!='')//如果有指定弹出层为提示信息层
	{
		var msgClass='';
		switch(settings.isMsg)
		{
			case 'normal':
			msgClass= 'dopop_reminder';
			settings.html=settings.html||"温馨提示";
			break;
			case 'error':
			msgClass= 'dopop_error';
			settings.html=settings.html||"出错了！";
			break;
			case 'success':
			msgClass= 'dopop_success';
			settings.html=settings.html||"成功了！";
			break;
			case 'dialog':
			msgClass= 'dopop_dialog';
			settings.html=settings.html||"是否确定？";
			break;
			default:
			msgClass= 'dopop_reminder';
			settings.html=settings.html||"温馨提示";
			break;
			
		}
		
		
		
		settings.title=settings.title||"温馨提示";
        if (settings.tips) {
            settings.html = "<div class='" + msgClass + "'><a href='javascript:;' id='showHtml' title='点击查看详细错误信息'></a><div class='clip'><div id='clip_container'><span id='clip_button'>复制</span></div></div><script type='text/javascript' src='" + stx + "/js/v2012/public/ZeroClipboard.js'></script>" + settings.tips + "<p id='fe_text'>" + settings.html + "</p></div>";
        } else {
            settings.html = "<div class='" + msgClass + "'>" + settings.html + "</div>";
        }	
	}
	
	
	
	
	
	var popCon = null,popBox = null,bButton=null;
		
	var _cover = $.fn.nanagePopu.apToObj(settings.cover);
	
	
	
	
	if(_cover.find("#"+settings.id).length<1)//如果还没创建以该ID为标识的弹出层 创建该弹出层	
	{
		var _h2=settings.button!=""?settings.height-50:settings.height;
		if(settings.button!="")_h=_h-50;
		var _h = !settings.tips && settings.height != null ? "style='height:" + _h2 + "px;overflow-y:auto;'" : '';
		
		_cover.append("<div id='pop_Box' class='popBox'><div class='filter'><iframe></iframe><div class='fiIframe'></div></div><div class='pop' ><div class='t'><div><span class='fl'></span><span id='closeBtn' class='closeBtn' title='点击关闭'></span></div></div><div class='popBoxContent'><div class='c'  "+_h+"></div><div class='b'></div></div></div></div>");
		
		popBox = _cover.find("#pop_Box").attr('id',settings.id);
		popCon = popBox.find('.pop');
		
		
		var popHeadle = popCon.find(".t");
        if (!settings.tips) {
            popCon.find(".c").html(settings.html);
        } else {
            popCon.find(".c").html(settings.html);
            popCon.find("#showHtml").toggle(function() {
                popCon.width(w2);
                popCon.find(".c").addClass("c2").css({ "height" : _h2,  "overflow-y" : "auto" });
                popBox.nanagePopu.add(settings).show(settings.id, settings.cover);
                copyTxt();
            }, function() {
                popCon.width(w);
                popCon.find(".c").removeClass("c2").css({ "height" : "auto",  "overflow-y" : "visible" });
                popBox.nanagePopu.add(settings).show(settings.id, settings.cover);
            })
        }
			
		
		bButton = popCon.find('.b');
		
		
		if(settings.button!=''){
			bButton.html(settings.button).show();
		}
		else
		{
			bButton.hide();
		}
		
		
		popCon.find(".t .fl").html(settings.title);
		
		//popBox.nanagePopu.add(settings);		
		
		
	}
	else
	{
		var _h2=settings.button!=""?settings.height-50:settings.height;
		
		popBox = _cover.find("#"+settings.id);
		popCon = popBox.find(".pop");

		popCon.find(".c").removeClass("c2").css({ "height" : "auto",  "overflow-y" : "visible" });
		
		bButton = popCon.find('.b');
		popCon.find(".t .fl").html(settings.title);
        if (!settings.tips) {
            popCon.find(".c").html(settings.html);
        } else {
            popCon.find(".c").html(settings.html);
            popCon.find("#showHtml").toggle(function() {
                popCon.width(w2);
                popCon.find(".c").addClass("c2").css({ "height" : _h2,  "overflow-y" : "auto" });
                popBox.nanagePopu.add(settings).show(settings.id, settings.cover);
                copyTxt();
            }, function() {
                popCon.width(w);
                popCon.find(".c").removeClass("c2").css({ "height" : "auto",  "overflow-y" : "visible" });
                popBox.nanagePopu.add(settings).show(settings.id, settings.cover);
            })
        }	
		if(settings.button!='')
		{
			
			popBox.find(".b").html(settings.button);
			if(!settings.tips && settings.height!=null) popBox.find(".c").css({'height':settings.height-50});		//如果二次传入含有指定高度，即重新定义弹出层高度，这里 -50为减掉按钮行高度
					
		
		}
		else
		{
			
			if(!settings.tips && settings.height!=null) popBox.find(".c").css({'height':settings.height});		//如果二次传入含有指定高度，即重新定义弹出层高度，这里 -50为减掉按钮行高度
			bButton.hide();
		}		
	}
	
	
	popCon.width(w);
	popBox.nanagePopu.add(settings).show(settings.id,settings.cover);
	//$.fn.nanagePopu.setZindex(settings.id,settings.cover);
	
	if(settings.drag)//如果是可以拖动的
	{
		popBox.dragDrop.init(settings);
	}	
	
	
	//执行回调函数
	/*
	if(settings.callBack!=null)
			{
				if(typeof(settings.callBack)=="string"){//如果回调方法传入为字符串类型
							eval(settings.callBack);
						}else{
							settings.callBack();
						}; 	
			}	
	*/
}

var clip = null;
function copyTxt() {
    //if (clip) return;
    clip = new ZeroClipboard.Client();
    clip.setHandCursor(true);
    clip.addEventListener('mouseOver', function (client) {
        // update the text on mouse over
        clip.setText( jQuery("#fe_text").html() );
    });

    clip.addEventListener('complete', function (client, text) {
        //debugstr("Copied text to clipboard: " + text );
        alert("详细错误信息已经复制，你可以使用 Ctrl+V 粘贴。");
    });
    clip.glue('clip_button', 'clip_container');
}
/*
 * 功能：生成配置步骤
 * var mystep = new step({id:'myStep',title:'网站页面配置步骤：',items:['页面信息填写','页面配置','关联业务配置','预览测试','提交审核']});
 */
function step(options){
	var defaults={		
		    //默认选项配置		
			id:'stepBox',//配置步骤ID 默认为stepBox
			appTo:$(document.body),//配置步骤要添加到那个节点上 默认添加到 document.body 前面
			title:"",//配置步骤标题 默认为空
 			items:[],//配置步骤
 			on:0//默认高亮显示哪个步骤 默认为第一个 从0开始算
			};
					
	
	var settings = jQuery.extend({}, defaults, options);//合并defaults 和 options 不修改 defaults
	
	var stepBox = null,stepTit = null,step=null;
	
	if($("#"+settings.id).length<1)//如果还未创建过以该ID为标识的步骤
	{
		stepBox = $("<div>",{'class':'stepBox','id':settings.id}).appendTo($(settings.appTo));
		stepTit = $("<div class='tit'></div>").appendTo(stepBox);
		step = $("<div class='step'></div>").appendTo(stepBox);
		
	}
	else
	{
		stepBox = $("#"+settings.id);
		stepTit = stepBox.find("div.tit");
		step = stepBox.find("div.step");
	}
	
	stepTit.html(settings.title);
	
	var olis = $("<ol></ol>").appendTo(step);
	
	//创建
	$.each(settings.items,function(i,n){		
		
		var li = $("<li></li>").append($("<span></span>").append($("<label></label>").html(n)));		
		olis.append(li);
		
	});
	
	
	var lis = olis.find("li");
	var lisLength = lis.length;
	lis.first().addClass("li-first");
	lis.last().addClass("li-last");
	
	//高亮定位	
	lis.eq(settings.on).find("span").addClass("on");
	
	
	
	
	this.cur = function(tag){
		
		var t = tag;
		//olis.find("li").eq(settings.on).find("span").addClass("on");
		if(t>lisLength-1)
		{
			t = lisLength-1;
		}
		
		//alert(t)
		$.each(lis,function(i,n){
						
			
			if(i<t)
			{
				$(n).find("span").removeClass().addClass("pre");
				if(i==t-1)
				{
					$(n).find("span").removeClass().addClass("pre-last");
				}
			}
			else
			{
				 if(i>t)
				 {
				 	$(n).find("span").removeClass("on").addClass("last");
				 }
				 else if(i==t)
				 {
				 	$(n).find("span").addClass("on");
				 }
			}
			
		});
		
	};
	
	this.cur(settings.on);
	//alert(stepBox.html())
}
function loadingfunc(options){
	/*
	功能:
	loading效果		
	*/
	var defaults={		
		    //默认选项配置		
			id:'loading',//loadingid 默认为loading
			sub:'.pop',//弹出层二层选择器 默认为.pop
			cover:self,//要遮盖的窗体 默认遮盖当前窗体 父窗体为top 
			html:"数据读取中，请稍候...",//填充的内容	 			
 			closeTimeOut:0,//超时多少秒自动关闭弹出loading层 默认不关闭 必须为数字
 			esckey:false,//是否开启ESC关闭弹出层的功能 默认不开启
 			zIndex:100,//弹出层的优先级 值越大优先级越高 默认为100 后弹出的层优先 注意：父窗体的弹出层比子窗体的弹出层优先级高
 			closeCallBack:function(){},//关闭后的回调函数 不能够是一条语句 如果要带参数closeCallBack:function(){你的函数名(你的参数);} 不带参数closeCallBack:你的函数名
 			closeBtnShow:true,//弹出层是否显示关闭按钮 默认显示
 			isLock:true,//是否锁屏 默认锁屏
 			isAnimate:false,//是否开启效果 默认不开启
 			drag:false,//可拖动 默认不可拖动
 			width:150,//loading层宽度 默认150像素
 			isCenter:true,//是否居中，默认不居中
 			isHide:false, //是否要去除弹出层 默认不去除
			obj:$('body'), //需要定位loading状态层的容器 默认是当前body 【如果cover:top，则该参数无效】
			isbg:true,//遮罩层是否是灰色？默认是
			callBack:null//弹出层创建完毕的回调函数
			};
					
	
	var settings = jQuery.extend({}, defaults, options);//合并defaults 和 options 不修改 defaults
	//var _cover = $.fn.nanagePopu.getCover(settings.cover);
	var _apToObj = $.fn.nanagePopu.apToObj(settings.cover);
	var obj = _apToObj.find("#"+settings.id);			
			
	
	var filter=settings.isLock==true?"<div class='filter'><iframe></iframe><div class='fiIframe'></div></div>":"";
	
	if(obj.length==0)
		{			
			_apToObj.append("<div class='loading' id='loading'>"+filter+"<div class='pop'><div class='t'><div class='closeBtn' id='closeBtn'></div></div><div class='c'></div></div></div>");
			obj = _apToObj.find('#loading').attr('id',settings.id);
			
		}
		
	
	obj.find('.c').html(settings.html);
	obj.find(".pop").width(settings.width);
	obj.nanagePopu.add(settings).show(settings.id,settings.cover);
	
	
	
	
}



function ie6BgBug(){
	/*
	功能:
	修复IE6 背景不缓存BUG
	*/
	if($.browser.msie&&$.browser.version==6.0)
	{  
		try{  
			document.execCommand("BackgroundImageCache", false, true);  
		}catch(e){}  
	} 	
}
ie6BgBug();

 


function _getJQueryById(id) {
	/**
	 * 根据ID,获取JQuery对象,ID里面可包含'.'字符串，返回jQuery对象
	 * 
	 * @param id
	 *            对象名称
	 */
	var _id = id;	
	if (typeof (_id) == "string") {
		if (_id.charAt(0) != '#') {
			_id = "#" + _id;
		}
		if (_id.indexOf('.') != -1) {
			_id = _id.replace(/\./g, "\\.");
		}
	}
	return jQuery(_id);
}


function inputTipsText(options){		
	/*功能:
	控件输入提示
	参数：
	obj:(obj)为控件对象
	选项：
	tipsText:(str) 控件提示文字，可以在控件中parameter属性定义，也可以不传
	
	使用示例：
	inputTipsText({obj:jQuery('#id')})
	*/
	
	var obj=options.obj;
	 var tipsText=options.tipsText;
	 
		 var _tipsText;
 
	 
	 if($(obj).attr("parameter")!=undefined){
		 
	 
		
	if($(obj).attr("type")=="checkbox"){	//如果控件为了checkbox类型
	
		var _o=	$(obj).parents("form").find("input:[name='"+$(obj).attr("name")+"']").not('[type="hidden"]').eq(0);
		var _p=evalJSON(_o.attr("parameter"));
		var textStr;								//设置默认提示
		if(_p.minLen!=undefined&&_p.maxLen!=undefined){
			textStr="请选择"+_p.minLen+"-"+_p.maxLen+"个选项";
		}else if(_p.minLen!=undefined&&_p.maxLen==undefined){
			textStr="请选择"+_p.minLen+"个或"+_p.minLen+"个以上选项";	
		}else if(_p.minLen==undefined&&_p.maxLen!=undefined){
			textStr="请选择"+_p.maxLen+"个或"+_p.maxLen+"个以下选项";	
		}
		
		tipsText=_p.tipsText||textStr;
		
	}
	 }
	
	if($(obj).attr("parameter")!=undefined||tipsText!=undefined){	//如果控件存在parameter参数
		var parameter=evalJSON($(obj).attr("parameter"));
		var form=obj.parents("form")[0];
		var tipsText=tipsText||parameter.tipsText;
		var html;
		
		
		if($(obj).attr("parameter")!=undefined){
			if(evalJSON($(obj).attr("parameter")).type=="select"){
				
				obj=$(obj).parents("span");		//如果控件类型为模拟控件
				var _p=evalJSON($(obj).attr("parameter"));
				if(_p!=undefined){
					
					tipsText=_p.tipsText;
				}
				//tipsText="请选择";
			}
		}
		_tipsText=tipsText;																													
		if(tipsText==undefined||tipsText==""){
				var minLen=parameter.minLen;	
				var maxLen=parameter.maxLen;	
				var q="";
				
				if(minLen!=undefined&&maxLen!=undefined){
					q=minLen+"-"+maxLen+"位的";
				}else if(minLen!=undefined&&maxLen==undefined){
					q="不少于"+minLen+"位的";
				}else if(minLen==undefined&&maxLen!=undefined){
					q="不大于"+maxLen+"位的";
				}
				switch(parameter.type){
				
				case "str":
					tipsText="请输入"+q+"内容！";
				break;
				case "mobile":
					tipsText="请正确输入11位数的移动手机号码！";
				break;
				case "tel":
					tipsText="请正确输入电话号码，格式如：020-88888888";
				break;
				case "en":
					tipsText="请正确输入"+q+"英文数字-_！";
				break;
				case "date":
					tipsText="请输入日期，格式如：1985-01-01";
				break;
				case "cn":
					tipsText="请正确输入"+q+"中文字符！";
				break;
				case "mail":
					tipsText="请正确输入Email！";
				break;
				case "url":
					tipsText="请正确输入网址，格式如：http://gd.10086.cn";
				break;
				case "idCard":
					tipsText="请正确输入15或18位的身份证号码！";
				break;
				case "num":
					tipsText="请正确输入"+q+"整数值！";
				break;
				case "decimal":
					tipsText="请正确输入"+q+"数值";
				break;
				
				
				default:
					tipsText="请正确输入"+q+"内容";
				break;
			
				}	
				if(obj.attr("type")=="checkbox"||obj.attr("type")=="radio"||obj[0].tagName=="SELECT"){
					tipsText="请选择";
				}else if(obj.attr("type")=="password"){
					tipsText="请正确输入"+q+"密码！";
				}
		}
		
			var _style="";
			var _offset=$(obj).offset();
			var offset2=$(obj).offsetParent().offset();
			
			var _objW=$(obj).outerWidth();
			var _objH=$(obj).outerHeight();
			var _left2=offset2.left;
			var _top2=offset2.top;
			var _left='';
			
			
			var _top=_offset.top-_top2;
			if($(obj).parent().children().not('em').length>1){
				var _parentChild=$(obj).parent().children();
				var _oL=_parentChild.not('em').not('.limit').length;		//.limit 为输入长度显示行的p标签
				
				_objW=_parentChild.eq(_oL-1).outerWidth();
				
				_left=_parentChild.eq(_oL-1).offset().left+_objW-5-_left2;
				
			}else{
				_left=_offset.left+_objW-5-_left2;
				
			}
			
			 _style='left:'+_left+'px;top:'+_top+'px;';
			
			if(_tipsText!=false){
			html='<em class="inputTips" style="'+_style+'">'+tipsText+'<em></em></em>';	
			if($(obj)[0].tagName=='TEXTAREA'){
				
				if($(obj).css('visibility')=='hidden'){	//如果textare 为 hidden 是，即默认他为第三方编辑器的载体控件，提示语转为不是浮动层
					html='<em class="inputTips inputTips0">'+tipsText+'</em>';
				}
			}
		
				if($(obj).parent().find(".inputTips").length==0){	//如果当前对象的父标签中不存在提示层
					
					if($(form).find(".inputTips").length==0){		//再检查当前对象表单中，其它位置是否存在提示层，如果不存
						$(form).find(".inputTips").remove();	//先清除form中的提示，再进行了重新插入
							
						
						if(obj.next(".inputOk").length==0){	//如果不存在校验成功标签
							
						
							if($(obj).nextAll(".inputTips").length==0){	//如果控件对象后面不存在输入提示层
							
							if($(obj).parent().find('.limit').length){	//如果td中存在输入长度提示行，(还可以输入xxx个字符)
								$(obj).parent().find('.limit').before(html);
							}else{
								obj.parent().append(html);
							}
					
					
								var _w=_offset.left+$(obj).outerWidth()
								var _w2=$('body').width();
								var _w3=280;
								var _w4=_w2-_w;
								var _w5=$(obj).nextAll(".inputTips").outerWidth();
							
								if(_w5<=_w4)_w3=$(obj).nextAll(".inputTips").outerWidth();
							
								
								if(_w4>=_w3+20){		//正常造右显示
									
								if($(obj).nextAll(".inputTips").outerWidth()>280)$(obj).nextAll(".inputTips").css({"width":280+'px','white-space':'normal'});	//这里white-space针对ie6而定义
								
								}else{	//控件顶部显示
									
								$(obj).nextAll(".inputTips").addClass('inputTips2');
							
								if($(obj).nextAll(".inputTips").outerWidth()>167){
									$(obj).nextAll(".inputTips").css({"width":$(obj).outerWidth()-22+'px','white-space':'normal'});	//这里white-space针对ie6而定义
								}else{
										$(obj).nextAll(".inputTips").css({"width":167+'px','white-space':'normal'});	//这里white-space针对ie6而定义
								}
								$('.inputTips2').css({top:_offset.top-$('.inputTips2').outerHeight()-5,left:_offset.left});
									
								}
							}
						}
						 
						 
					if($(obj).val()=="")$(obj).parent().find(".inputOk").remove();			//如果控件值为空，即把正确标签删除
					
					
						return false;
					}else{	//如果存在则删除
						
						$(form).find(".inputTips").remove();	//先清除form中的提示，再进行了重新插入
						return false;
					}
				
				}
			}
	}
	
	
	
}

function inputTips(options){
	/*
	功能：
	校验状态提示
	参数：
	obj:对应的控件对象
	status:校验通过情况，false为不通过，true为通过

	返回值：
	true或false
	使用示例：
	<input type="text" id="inputId") value="请输入手机号码"/>
	inputTips($('inputId'),true);	
	*/

	 		//如果为input类型的，即使用以下形式提示
	
	var obj=options.obj;
	var status=options.status;
	//var text=options.text;
	var tipsText=options.tipsText;
	var cls=status==true?"inputOk":"inputErr";
	
			var _i;
			var _o;
			var _type;
		
			if($(obj).attr("parameter")!=undefined)  _type=evalJSON($(obj).attr("parameter")).type;
			
			if(_type=="select"){		//判断类型是否为模拟select

				//console.info("obj==="+obj+";;;;;"+$(obj).parents("span"));
				_i=$(obj).parents(".dropdownlist").parent().find("i");
				_o=$(obj).parents(".dropdownlist").parent().find(":[parameter]");
				obj=$(obj).parents(".dropdownlist");	
				//alert("");	

				
			}else{
				_i=$(obj).parent().find("i");
				_o=$(obj).parent().find(":[parameter]");
			}
			
			var _offset=$(obj).offset();
			var _objW=$(obj).outerWidth();
			var _objH=$(obj).outerHeight();
			var _left='';

			
			
			var _top=_offset.top+_objH/2-9;
			if($(obj).parent().children().not('i').not('em').not('textarea').length>1){
				var _parentChild=$(obj).parent().children();
				var _oL=_parentChild.not('i').not('em').length;
				_objW=_parentChild.eq(_oL-1).outerWidth();
				_left=_parentChild.eq(_oL-1).offset().left+_objW;
			}else{
				_left=_offset.left+_objW;
			}
			
			//var _style=' style="left:'+_left+'px;top:'+_top+'px;"';
			var _style="";
	
		 	var html='<i class="'+cls+'" '+_style+'>&nbsp;</i>';
			
		 if(status==true){	//如果校验通过
			 	
				$(_o).siblings(".inputTips").remove();		//如果校验成功，即删除当前对象中的提示层
				if(_o.length>1){	//如果控件对象标签容器中的控件大于1个
					var _n=0;
					
					for(var n=0;n<_o.length;n++){
						var _par=evalJSON(_o.eq(n).attr("parameter"));
						if(_o.eq(n).attr("parameter")!=undefined){
							// alert(_o.eq(n).attr("parameter"));
							 if(inputCheck({obj:$(_o.eq(n)),type:_par.type,minLen:_par.minLen,maxLen:_par.maxLen})){
  								 _n+=1;
							 }
							//alert(_o.eq(n).val());	
						}
					}
					
					if(_o.length==_n){	//如果对象父标签容器中所有控件通过校验
						if(_i.length<1){	//如果不存在提示对象
							//$(obj).after(html);	//即插入提示对象
								if($(obj).parent().find(".inputTips").length>0){	//如果存在输入控件提示层，则在提示层前插入错误提示符号
									$(obj).parent().find(".inputTips:first").before(html);
								}else{;
									$(obj).parent().append(html);
								}
						}else{											//否则已存在提示对象
							//$(obj).next("i").removeClass().addClass(cls);	//更新提示对象内容
							$(obj).siblings("i").removeClass().addClass(cls);	//更新提示对象内容
						}
					}else{
						_i=$(obj).parent().find("i");
						
						if(_i.length<1){	//如果不存在提示对象
						
							//$(obj).after(html);	//即插入提示对象
								if($(obj).parent().find(".inputTips").length>0){	//如果存在输入控件提示层，则在提示层前插入错误提示符号
									$(obj).parent().find(".inputTips:first").before('<i class="inputErr"  '+_style+'>&nbsp;</i>');
								}else{;
									$(obj).parent().append('<i class="inputErr" '+_style+'>&nbsp;</i>');
								}
						}
					}
					 _n="";
					 
				}else{	//否则对象父标签容器控件为1个
					
					
					
					if(_i.length<1){	//如果不存在提示对象
					
						//$(obj).after(html);	//即插入提示对象
						if($(obj).parent().find(".inputTips").length>0){	//如果存在输入控件提示层，则在提示层前插入错误提示符号
							$(obj).parent().find(".inputTips:first").before(html);
						}else{
							
							if($(obj).parent().find('.limit').length){	//如果td中存在输入长度提示行，(还可以输入xxx个字符)
							$(obj).parent().find('.limit').before(html);
							}else{
							$(obj).parent().append(html);
							}
						
						}
						
						
					}else{											//否则已存在提示对象
						//$(obj).next("i").removeClass().addClass(cls);	//更新提示对象内容
						$(obj).siblings("i").removeClass().addClass(cls);	//更新提示对象内容
						
					}
			
				}
			// return true;
			 
		 }else{
			 
		   if(_type=="select"){
			   _o=$(obj).parents("span").parent().find(".inputTips").remove();
		   }else{
			  $(_o).siblings(".inputTips").remove();		//如果焦点离开后，对象校验失败，即删除当前对象中的提示层
		   }
		  
		 
		  
			if(_i.length<1){	//如果不存在提示对象
				if($(obj).parent().find(".inputTips").length>0){	//如果存在输入控件提示层，则在提示层前插入错误提示符号
					$(obj).parent().find(".inputTips:first").before(html);
				}else{
					
					
					if($(obj).parent().find('.limit').length){	//如果td中存在输入长度提示行，(还可以输入xxx个字符)
					$(obj).parent().find('.limit').before(html);
					}else{
					$(obj).parent().append(html);
					}
				}
				
			}else{											//否则已存在提示对象
				$(obj).siblings("i").removeClass().addClass(cls)
				
				var _f=$(obj).parents("form");
				var _t=_f.find(".inputErr:first").siblings(0);
				
			}
			 if($(obj).attr('type')=='checkbox'||$(obj).attr('type')=='radio')inputTipsText({obj:$(obj),tipsText:tipsText});	//如果控件为checkbox或radio即调用提示语句层

		 }
 				
}


 

function inputTips2(options){
	/*
	功能：
	校验状态提示
	参数：
	obj:对应的控件对象
	status:校验通过情况，false为不通过，true为通过
	使用示例：
	<input type="text" id="inputId") value="请输入手机号码"/>
	inputTips($('inputId'),true);	
	*/


	
	var obj=options.obj;
	var status=options.status;
//	var text=options.text;
	var tipsText=options.tipsText||'请正确输入内容';

	
	$(obj).parent().find(".inputTips").remove();
	if($(obj).attr("type")=="text"||$(obj).attr("type")=="password"){//如果为input类型的，即使用以下形式提示
	//if($(obj).attr("tagName")=="INPUT"){		
	
		if(status){		//如果status为true，即校验通过
			$(obj).removeClass('input1_focus').removeClass('inputErr').addClass('inputOk');
			//return true;
		}else{
			$(obj).removeClass('inputOk').addClass('inputErr').removeClass('input1_focus');
			
		}
	}else{	//如果非INPUT类的控件
		 var cls=status==true?"inputOk":"inputErr";
		 var html='<i class="'+cls+'">&nbsp;</i>';
			if($(obj).parent().has("i").length<1){	//如果不存在提示对象
				$(obj).parent().append(html);	//即插入提示对象
			}else{											//否则已存在提示对象
				$(obj).siblings("i").removeClass().addClass(cls);	//更新提示对象内容
			}		
	}
}


function inputTips3(options){
	/*
	功能：
	弹出对话框校验提示
	参数：
 	status:(bloonea)校验通过情况，false为不通过，true为通过
	tipsText:(str)  提示语
	使用示例：
	<form>
	<input type="text" class="mid" name="abc"   parameter="{type:'str',minLen:4,maxLen:10,need:true,callTips:inputTips3}" value=""/>
	<button id="send">test</button>
	</form>
	$('#send').verifyForm();	
	*/
	var obj=options.obj;
 	var status=options.status;
	var tipsText=options.tipsText||'请正确输入内容！';
	if(!status){	//如果校验不通过
		winPop({isMsg:'error',id:'_'+$(obj).attr('name'),html:tipsText});
		return false;
	}
	
 }




function SVerifyErr(options){		//这个是服务端校验失败后调用的方法
	/*功能:
	这个是服务端校验失败后调用的方法
	参数：
	obj:(obj)为对应的控件对象
	选项：
	status:(boolean) 状态，默认为false错误，true为正确
	tipsText:(str) 提示信息，如果不传则会读取控件parameter的tipsText值，如果都不存在，方法会根据parameter中的type类型默认一句通用提示
	示例：
	SVerifyErr({obj:jQuer("#id")});
	SVerifyErr({obj:jQuer("#id"),status:true});
	*/
	//$(obj).focus();					//对象控件获得焦点
	
	var defaults={	//默认值
		status:false
	}
	var settings=$.extend(defaults,options);	
	var obj=settings.obj;
	var status=settings.status;
	inputTips({obj:obj,status:status});	//错误提示
	if(!status)inputTipsText({obj:obj,tipsText:options.tipsText});	//控件输入提示
	if(!status)formProcess({lock:status});	//恢复表单锁定
	$(obj).parents("form").find(".inputErr:first").parent().children().eq(0).focus();
}


function forVerify(){
	/*
		功能： 
		针对自定义传入多个控件校验对象，本方法暂时对 checkbox,radio,select不支持
		参数：
		控件对象数组
		返回值：
		boolnea,通过则返回 true，不通过返回 false
		示例：
		<form>
			<input type="text" id="uname" parameter="{type:'str',minLen:2,maxLen:4}"/>
			<input type="password" id="pwd"  parameter="{type:'str',minLen:2,maxLen:4}"/>
		</form>
		forVerify(jQuery('#uname'),jQuery('#pwd'));
	*/

	var obj;
	var n=0;
	for(var i=0;i<arguments.length;i++){
	obj=arguments[i];
		if($(obj).attr("parameter")!=undefined){
			var p=evalJSON($(obj).attr("parameter"));
			if(inputCheck({obj:$(obj),type:p.type,minLen:p.minLen,maxLen:p.maxLen,callTips:p.callTips,conf:p.conf,need:p.need,tipsText:p.tipsText})==true){
				inputTips({obj:$(obj),status:true,text:p.value,tipsText:p.tipsText});	
				n+=1;
			}else{
				inputTips({obj:$(obj),status:false,text:p.value,tipsText:p.tipsText});	
			}
		}
	}
		if(n==arguments.length){
				return true;
			}else{
				return false;
		}
}



/*
 * 弹出层管理插件
 * 只能管理用该插件添加的弹出层
 * 用其它方法弹出的层不能管理
 */


(function($){ 
	arrPopu = []; //用于存储弹出层的数组
	var _closeTimeOut = null;
	
	/*
	 * 功能：获取弹出层的最顶层 内部函数
	 * 参数: 无
	 * 返回:存储弹出层数组下标 如果无弹出层 则返回-1
	 */
	
	
	
	if(top.window['_zIndexNo'] == undefined)
	{
		top.window['_zIndexNo'] = 0;
	}
	else
	{
		top.window['_zIndexNo']=top.window['_zIndexNo']+1;
	}
	
	 var zIndexNo = top.window['_zIndexNo'];

	

	var getTopPopu= function(arr){		
		var _index = -1,_zIndex=-1;
		$.each(arr,function(i,n){	
		
			//var _cover = $.fn.nanagePopu.getCover(n.cover);
			
			var _apToObj = $.fn.nanagePopu.apToObj(n.cover);
			
			var o = _apToObj.find('#'+n.id);				
			if(o.css('display')!='none')
			{							
				var z = parseInt(o.css('zIndex'),10);					
				if(isNaN(z)){z=0;};
				if(z>=_zIndex){
					_zIndex = z;
					_index = i;
				}
			}
		});
		//alert(_index)
		//zIndexNo=zIndexNo+1;
		return _index;
		//return zIndexNo;
	}
	/*
	 * 功能：开启按Esc键关闭弹出层 内部函数
	 * 存在一个BUG 先弹出一个覆盖父页面的框，然后再弹出一个覆盖子页面的框，按ESC键可以取消子弹出框 但是不能取消父弹出框
	 * 如果有GIF动画 按ESC键会停止
	 */
	
	var closeKey = function(evt){
					var e = evt || window.event;
					if (e.keyCode == 27){
						var _index = getTopPopu(arrPopu);
						if(_index>-1&&arrPopu[_index].escKey)
						{
							var o = arrPopu[_index];
							$.fn.nanagePopu.hide(o.id,o.cover);
													
						}
					}				
			};
		
	$(document).bind('keyup', closeKey);
	//$(document).bind('click',closePopu);
	//var settings={};
    $.fn.nanagePopu={
		/*
		 * 功能：添加一个弹出层
		 * 参数：请参考配置参数
		 * 返回：本身
		 */
		add:function(options){
			var defaults = {
				id:'',//弹出层ID
				sub:'.pop',//弹出层二层选择器 默认为.pop
				closeBtn:'#closeBtn',//弹出层关闭按钮 默认为 closeBtn
				closeBtnShow:true,//弹出层是否显示关闭按钮 默认显示
				zIndex:100,//弹出层的优先级 值越大优先级越高 默认为100 后弹出的层优先
				cover:self,//要遮盖的窗体 默认遮盖当前窗体 父窗体为top
				esckey:false,//是否开启ESC关闭弹出层的功能 同时开启点外部遮盖层可以关闭弹出层 默认不开启
				closeCallBack:function(){},//关闭后的回调函数 不能够是一条语句 如果要带参数closeCallBack:function(){你的函数名(你的参数);} 不带参数closeCallBack:你的函数名
				closeTimeOut:0,//弹出层延时多少毫秒自动关闭 默认不关闭
				isLock:true,//是否锁屏 默认锁屏
				isAnimate:true,//是否开启效果 默认开启
				isCenter:true,//是否居中，默认居中
				isHide:false, //是否要去除弹出层 默认不去除
 		    	obj:$('body'), //需要定位loading状态层的容器 默认是当前body 【如果cover:top，则该参数无效】
 		    	isbg:true,//遮罩层是否是灰色？默认是
				callBack:null//弹出层创建完毕的回调函数
			};
			
			var settings = jQuery.extend({}, defaults, options);//合并defaults 和 options 不修改 defaults
			
			if(settings.cover==self)
			{
				var _contents = $('.tabIframe:visible:eq(0)',top.document).contents(); 
				if(_contents.length>0)
				{
					settings._cover = _contents;
				}
			}
			
			
			if(settings.id!='')//如果ID不为空
			{		
				var t = $.fn.nanagePopu.isHas(settings.id,settings.cover);				
				if(t==-1)//弹出层不存在数组里则添加
				{							
					var _cover = $.fn.nanagePopu.apToObj(settings.cover);
					var dom = _cover.find('#'+settings.id);
					arrPopu.push(settings);	
					//绑定关闭方法及效果					
					dom.find(settings.closeBtn).click(function(e){				
						$.fn.nanagePopu.hide(settings.id,settings.cover);
						//alert(settings.id);
						e.stopPropagation();
					}).hover(function(){
						$(this).addClass("closeBtn-02");
												
						},function(){
							$(this).removeClass("closeBtn-02");
							});	
					dom.css("zIndex",settings.zIndex);	
				}
				else//已经存在 则修改
				{
					
					$.fn.nanagePopu.edit(settings);
							
				}
				
			//$.fn.nanagePopu.setZindex(settings.id,settings.cover);		
			
			
			}
			
			return this;			
			
		},
		/*
		 * 功能：修改配置参数
		 * 参数 同add
		 * 返回:本身
		 */
		edit:function(options){
			var defaults = {
				id:'',//弹出层ID
				sub:'.pop',//弹出层二层选择器 默认为.pop
				closeBtn:'#closeBtn',//弹出层关闭按钮 默认为 closeBtn
				closeBtnShow:true,//弹出层是否显示关闭按钮 默认显示
				zIndex:100,//弹出层的优先级 值越大优先级越高 默认为100 后弹出的层优先
				cover:self,//要遮盖的窗体 默认遮盖当前窗体 父窗体为top
				escKey:false,//是否开启ESC关闭弹出层的功能 同时开启点外部遮盖层可以关闭弹出层 默认不开启
				closeCallBack:function(){},//关闭后的回调函数 不能够是一条语句 如果要带参数closeCallBack:function(){你的函数名(你的参数);} 不带参数closeCallBack:你的函数名
				closeTimeOut:0,//弹出层延时多少毫秒自动关闭 默认不关闭
				
				isLock:true,//是否锁屏 默认锁屏
				isAnimate:true,//是否开启效果 默认开启
				isCenter:true,//是否居中，默认居中
				isHide:false, //是否要去除弹出层 默认不去除
 		    	obj:$('body'), //需要定位loading状态层的容器 默认是当前body 【如果cover:top，则该参数无效】
 		    	isbg:true,//遮罩层是否是灰色？默认是
				callBack:null//弹出层创建完毕的回调函数
			};
			var settings = jQuery.extend({}, defaults, options);//合并defaults 和 options 不修改 defaults
			var t = $.fn.nanagePopu.isHas(settings.id,settings.cover);
			//alert(t);
			if(t==-1)
			{
				$.fn.nanagePopu.add(settings);
			}
			else
			{
				arrPopu[t]= options;
				
				//alert(t);
			}
		
		},
		/*
		 * 功能：判断是否存在
		 * 参数 id 弹出层ID【必需】 cover 弹出层所在的窗体
		 * 返回:存储弹出层数组下标 如果无 则返回-1
		 * 备注:如果同一个页面存在俩个同样的ID 侧选第一个
		 * 		如果没找到 到父页面或者当前页面查找
		 */
		isHas:function(id,cover){
			
			var re = -1;	
			
			//var _apToObj =  $.fn.nanagePopu.apToObj(cover);
			//var _cover =  $.fn.nanagePopu.getCover(cover);
			
			
			var _cover = cover||self;
			
			/*
			if(_cover==self)
			{
				var _contents = $('.tabIframe:visible:eq(0)',top.document).contents(); 
				if(_contents.length>0)
				{
					_cover = _contents;
				}
			}
			*/
			
			$.each(arrPopu,function(i,n){
				if((n.id==id)&&(n.cover==_cover))
				{
					re = i;
					//$('#heightdiv').html(n.id)
					
					return false;
				}				
			});
			
			
			
			//如果没找到 到父页面或者当前页面查找
			/*
			if(re==-1)
			{
				var _cover2 = _cover==top?self:top;	
				$.each(arrPopu,function(i,n){
				if(n.id==id&&n.cover==_cover2)
				{
					re = i;
					return false;
				}
				
				});
			}
			*/
			
		//	$('#heightdiv').html(arrPopu.length+':'+re)
			//alert(re)
			return re;			
			
		},
		/*
		 * 功能：设置弹出层的优先级 后弹出的层优先于当前的其它弹出层
		 * 参数 id 弹出层ID【必需】 cover 弹出层所在的窗体,nZindex 弹出层的优先级 数值越大优先级越高
		 * 返回：本身
		 */
		setZindex:function(id,cover,nZindex){
			var cover = cover||self;
			
			if(cover==self)
			{
				var _contents = $('.tabIframe:visible:eq(0)',top.document).contents(); 
				//var _contents = $('.tabIframe:visible:eq(0)').contents(); 
				if(_contents.length>0)
				{
					cover = _contents;
				}
			}
			
			
			try{
			//zIndexNo = zIndexNo+1;					
				
				if(nZindex!='undefined'){
					zIndexNo=nZindex>zIndexNo?nZindex:zIndexNo+1;
				}
				else
				{
					zIndexNo = zIndexNo+1;
					top.window['_zIndexNo']=top.window['_zIndexNo']+1;
				}
			
			if(zIndexNo>top.window['_zIndexNo'])
			{
				top.window['_zIndexNo']=zIndexNo;
			}
			else
			{
				zIndexNo=top.window['_zIndexNo'];
			}
			
			$(cover).find('#'+id).css("zIndex",zIndexNo);
				
				
			//console.info("zIndexNo>>>"+zIndexNo);	
			//}
			}catch(e){
				//alert(e)
				
			}
			return this;
		},
		/*
		 * 功能：显示弹出层
		 * 参数 id 弹出层ID【必需】 cover 弹出层所在的窗体
		 * 返回：本身
		 */
		show:function(id,cover){		
		var t = $.fn.nanagePopu.isHas(id,cover);
		var settings = arrPopu[t];
		//alert(id)
		if(t>-1)
			{	
				//clearTimeout(_closeTimeOut);	
				
				try{
						clearTimeout(_closeTimeOut);
					}catch(e){}
				
				var _popu = arrPopu[t];		
				
				if(_popu.isHide)//如果是去除弹出层
				{
					$.fn.nanagePopu.hide(id,cover);
					return this;
					
				}
				
				
												
				var _cover = $.fn.nanagePopu.getCover(_popu.cover);
				var _apToObj = $.fn.nanagePopu.apToObj(_popu.cover);
				
				if(!_popu.closeBtnShow){
					_apToObj.find('#'+id).find(_popu.closeBtn).hide();
					
				}
			
				var dom = _apToObj.find('#'+_popu.id);
				
				var _sub = dom.find(_popu.sub);
				dom.hide();
				_sub.hide();
				
				//如果不锁屏，
				if(!_popu.isLock){
					
					if(_popu.isCenter)
					{
						_sub.show().end().center(_cover).show(settings.callBack).width(_sub.width()).height(_sub.height()).center(_cover);
						_sub.center(dom);
					}
					else
					{
						_sub.show().end().show(settings.callBack).width(_sub.width()).height(_sub.height());
						
						//alert('dd')
						//_sub.center(dom);
					}
					
					
					
				}
				else{
					
					var kk = _cover.offset();
					
					
					if($.browser.msie&&$.browser.version==6)
					{
						dom.width(_cover.width()).height(_apToObj.parents()[0].clientHeight).css({left:kk.left,top:kk.top});
					}
					else
					{
						dom.width(_cover.width()).height(_cover.height()).css({left:kk.left,top:kk.top});
					}
					//dom.width(_cover.width()).height(_apToObj.parents()[0].clientHeight).css({left:kk.left,top:kk.top});
					//dom.width(_cover.width()).height(_cover.height()).css({left:kk.left,top:kk.top});
					
					//$('#heightdiv').html(self.document.documentElement.clientHeight);
					//alert(document.body.scrollHeight)
					//_apToObj.parents().css('overflow','hidden');
					
				//	var sH = _apToObj.parents()[0].scrollHeight-dom.offset().top;
					
					if(_popu.isAnimate){//如果开启了动画效果
					
					if(_popu.isCenter)
					{
					
						_sub.hide().center(dom).end().show(0,function(){						
						_sub.center(dom).show(0,function(){
							var sH = _apToObj.parents()[0].scrollHeight-dom.offset().top;
							dom.height(sH);							
							//dom.find('.filter').height(sH);
							if($.browser.msie&&$.browser.version==6)
							{
								dom.find('.filter').height(sH);
							}
							
								//执行回调函数

							if(settings.callBack!=null)
								{
									if(typeof(settings.callBack)=="string"){//如果回调方法传入为字符串类型
												eval(settings.callBack);
											}else{
												settings.callBack();
											}; 	
								}	
		
			
							
						});	
						});	
						
					}
					else
					{
						
						_sub.hide().end().show('slow',function(){						
						_sub.show(0,function(){
							var sH = _apToObj.parents()[0].scrollHeight-dom.offset().top;
							dom.height(sH);							
							//dom.find('.filter').height(sH);
							if($.browser.msie&&$.browser.version==6)
							{
								dom.find('.filter').height(sH);
							}
							//执行回调函数

							if(settings.callBack!=null)
								{
									if(typeof(settings.callBack)=="string"){//如果回调方法传入为字符串类型
												eval(settings.callBack);
											}else{
												settings.callBack();
											}; 	
								}	
		
						});	
						});	
					}	
							
					}else//如果没开启动画效果
					{	
					
					if(_popu.isCenter)
					{
						_sub.hide().center(dom).show().end().show();
						_sub.center(dom).show(function(){		
						var sH = _apToObj.parents()[0].scrollHeight-dom.offset().top;												
						dom.height(sH);
						//dom.find('.filter').height(sH);	
						if($.browser.msie&&$.browser.version==6)
						{
							dom.find('.filter').height(sH);
							//dom.find('.filter iframe').height(sH);
						}	
						
						//执行回调函数

							if(settings.callBack!=null)
								{
									if(typeof(settings.callBack)=="string"){//如果回调方法传入为字符串类型
												eval(settings.callBack);
											}else{
												settings.callBack();
											}; 	
								}	
		
											
						});		
							
					}
					else
					{
						_sub.show().end().show();
						_sub.show(function(){		
						var sH = _apToObj.parents()[0].scrollHeight-dom.offset().top;												
						dom.height(sH);
						//dom.find('.filter').height(sH);	
						if($.browser.msie&&$.browser.version==6)
						{
							dom.find('.filter').height(sH);
							//dom.find('.filter iframe').height(sH);
							//alert(dom.find('.filter iframe')[0].tagName)
						}
						
						//执行回调函数

							if(settings.callBack!=null)
								{
									if(typeof(settings.callBack)=="string"){//如果回调方法传入为字符串类型
												eval(settings.callBack);
											}else{
												settings.callBack();
											}; 	
								}	
		
												
						});		
						
					}
						
										
										
					}
				}
				
				if(_popu.isbg){//遮罩层是否是灰色
					dom.find('.filter').css('background','#000');
				}else
				{
					dom.find('.filter').css('background','#fff');
				}
				
				
				//如果开启了按ESC键关闭弹出层的功能 则同时开启点弹出层外部关闭弹出层
				if(_popu.escKey){	
					var clickToClose =  dom.find('.filter .fiIframe');	
					clickToClose.unbind('click').bind('click',function(){						
					$.fn.nanagePopu.hide(_popu.id,_popu.cover);
					});					
				}			
				//如果设置了延时，则延时多少毫秒后自动关闭弹出层	
				if(_popu.closeTimeOut)
				{					
					_closeTimeOut = setTimeout(function(){
					$.fn.nanagePopu.hide(_popu.id,_popu.cover);
					try{
						clearTimeout(_closeTimeOut);
					}catch(e){}
					},_popu.closeTimeOut);
				}
				
				
				$.fn.nanagePopu.setZindex(id,cover);
				
				/*
					var h = _popu.cover==top?top.document:document;
					dom.height($(h).height());
				*/
			
				//dom.find('.filter').width().height();
				//dom.bgiframe();
				
				
				if($.browser.msie&&$.browser.version==6)
				{
					$(window).scroll(function(){
						dom.find('.filter iframe').hide().show();
					});
				}
				
			}
			
		
		//执行回调函数
	/*
		if(settings.callBack!=null)
			{
				if(typeof(settings.callBack)=="string"){//如果回调方法传入为字符串类型
							eval(settings.callBack);
						}else{
							settings.callBack();
						}; 	
			}	
		
			*/
			/*
		if(_popu.isCenter){
			var st = parseInt(_sub.parents("body:eq(0)").scrollTop(),10);
			
			st = st+parseInt(_sub.css("top"),10);
			//alert(st)
			_sub.css({top:st});
		}*/
		return this;
		},
		/*
		 * 功能：隐藏弹出层
		 * 参数 id 弹出层ID【必需】 cover 弹出层所在的窗体
		 * 返回：本身
		 */
		hide:function(id,cover){		
		var t = $.fn.nanagePopu.isHas(id,cover);
		//alert(t)
		//alert(id)
		if(t>-1)
			{				
				var _popu = arrPopu[t];	
			//	var _cover = $.fn.nanagePopu.getCover(_popu.cover);
				var _apToObj = $.fn.nanagePopu.apToObj(_popu.cover);
				
				//alert(_apToObj.is('body'))
				
				//alert(t)
				var dom = $(_apToObj).find('#'+_popu.id);
				
				//alert(dom.attr('id'));
				//alert(_popu.id);
				var _sub = dom.find(_popu.sub);				
				
				//如果不锁屏，
				if(!_popu.isLock){					
					dom.hide(2,_popu.closeCallBack);					
				}
				else{
					if(_popu.isAnimate){//如果开启了动画效果
						_sub.hide().end().hide(0,_popu.closeCallBack);
					}else//如果没开启动画效果
					{
						dom.hide(2,_popu.closeCallBack).hide();
					}					
				}
								
				//dom.hide();
				//调用关闭弹出层回调函数
				//_popu.closeCallBack();
						
				//clearTimeout(_closeTimeOut);	
				try{
						clearTimeout(_closeTimeOut);
					}catch(e){}
				
			}
		
		return this;			
		},
		/*
		 * 功能：获取被覆盖的层
		 * 返回：被覆盖的层
		 */
		getCover:function(o){
			var re = {};
			
			
			
			if(o==self||o==top)
				{
					re = $(o.document.body);
				}
			else if(o=='top'){re = $(top.document.body);}
			else if(o=='self'){re = $(self.document.body);}
			else
				{
					re = $(o);
				}
				
			if(o==self)
			{
				var _contents = $('.tabIframe:visible:eq(0)',top.document).contents(); 
				if(_contents.length>0)
				{
					re = _contents.find('body:eq(0)');
				}
			}	
			
			return re;

		},
		apToObj:function(o){
			
			var re = $.fn.nanagePopu.getCover(o);
			return re.is("body")?re:re.parents("body");
		}
		
		
		
	};
	
})(jQuery);


//清除选择
var clsSelect = function(win){
		try{
			win.window.getSelection?win.window.getSelection().removeAllRanges():win.document.selection.empty();
			//window.getSelection?window.getSelection().removeAllRanges():document.selection.empty();
			
		}catch(_){
			try{
				window.getSelection?window.getSelection().removeAllRanges():document.selection.empty();				
				
				
			}catch(_){}
			
		};
	};


	
/*

 * 拖动插件
 */

$.fn.dragDrop = {
	
	//初始化拖动
	init:function(options){
		var defaults={
			id:'',//拖动对象
			dragHeadle:'.t',//拖动手柄
			cover:self
		};
		
		
		var settings = jQuery.extend({}, defaults, options);//合并defaults 和 options 不修改 defaults
		
		var o={},coords = {};
		var _cover = settings.cover;
		//alert(settings.isLock)
		if(settings.isLock){
			o = $(_cover.document.body).find('#'+settings.id).find(settings.sub);
		}else
		{
			o = $(_cover.document.body).find('#'+settings.id);
		}
		var off = o.offset();
		//o.css('margin',0).css(off);
		
		var headle =o.find(settings.dragHeadle).unbind('mousedown').bind('mousedown',function(e){
			var of = o.offset();
			coords ={x:e.pageX-of.left,y:e.pageY-of.top};
			$(this).css('cursor','move');
			//$(_cover.document).bind('mousemove',_mousemove).bind('mouseup',_mouseup);
			
			$(_cover.document).bind({mousemove:_mousemove,mouseup:_mouseup});
			
			return false;
		});
		
		
		
		function _mousemove(e){			
		var x = e.pageX - coords.x;
		var y = e.pageY - coords.y;
		//o.css('margin',0);
		o.offset({left:x,top:y});
		
		clsSelect(_cover);
		
		};
		function _mouseup(e){		
		headle.css('cursor','default');
		$(_cover.document).unbind('mousemove',_mousemove).unbind('mouseup',_mouseup);
		//headle.unbind('mousedown');
		}
		
		return this;
	}
	
	
};


 


var jet = {
	
/*
 * 功能：判断请求文件类型
 * 示例：getfileType('/path/kk.js')
 * 返回值: 
 * 		js文件 :js	
 * 		css文件:css
 * 		图片   :jpg
 * 		html   :html
 * 		其它   :url
 */


getfileType:function(f)
	{
		var _f= jQuery.trim(f).toLocaleLowerCase();		
		var m=Math.min(_f.indexOf('?')==-1?0:_f.indexOf('?'),_f.indexOf('#')==-1?0:_f.indexOf('#'));
		var d=m==0?(_f.length-3):(m-3);	
		var url = _f.slice(d,d+3);
		
		var re='url';
		switch(url)
		{			
			case 'jpg':
			case 'gif':
			case 'png':		
			re='jpg';
			break;
			case 'css':
			re = 'css';
			break;
			case '.js':
			re = 'js';
			break;
			case 'htm':
			case 'tml':			
			re = "html";
			break;
			default:
			re = 'url';			
			
		}
		return re;
	
		
	},




loadImage:function(options) {
	/*功能：图片加载
	 *参数说明：
	 *url要加载的图片URL
	 *callBack 加载完后的回调函数
	 */
    var img = new Image(); //创建一个Image对象，实现图片的预下载
    img.src = url;
   
    if (img.complete) { // 如果图片已经存在于浏览器缓存，直接调用回调函数
        callBack.call(img);
        return; // 直接返回，不用再处理onload事件
    }
//alert('sf')
//loading状态
//test();
    img.onload = function () { //图片下载完毕时异步调用callBack函数。
        callBack.call(img);//将回调函数的this替换为Image对象
    };
	//img = null;
},
	
/*
 * 功能：加载css 文件
 * 示例：jet.loadCss('/path/xxx.css')
 */
 
	
loadCss:function(url){
var head=document.getElementsByTagName('HEAD').item(0);
var style=document.createElement('link');
style.rel='stylesheet';
style.type='text/css';
style.href=url;

head.appendChild(style);

},	

/*
 * 功能:文件加载
 * 示例:
 * jet.load({url:'/path/xx.shtml',callBack:fn3,id:'inerId'})
 * jet.load({url:['/path/xx.shtml','/path/xx1.shtml','/path/xx2.shtml'],callBack:fn3,id:'inerId'})
 * 参数：
 * 		url:参数为要加载的文件url
 * callBack:加载成功后的回调函数
 * 		 id:要填入内容的元素ID（仅加载html文件和返回html或文本才生效）
 */

load:function(options){
	var defaults={
		url:'',		
		callBack:null,
		id:null
	};
	var config = jQuery.extend({}, defaults, options);
	
	if(jQuery.isArray(config.url))
	{
		jQuery.each(config.url,function(i,n){
			
			if(i!=(config.url.length-1))
			{
				jet.load(n);
			}
			else
			{
				jet.load({url:n.url});
			}
		})
	}
	else if(!!config.url)
	{
		//alert('fsd')
		//jet.console.info('sd');
		
		var t = jet.getfileType(config.url);
		
		if(t=='js')
		{
			jQuery.getScript(config.url,config.callBack);

		}
		else if(t=='htm'||t=='url')
		{
			if(!!config.id)
			{
				$('#'+config.id).load(config.url,config.callBack);
			}
			else
			{
				$.get(config.url,config.callBack);
			}
		}
		else if(t=='css')
		{
		
			jet.loadCss(config.url)
			$.get(config.url,config.callBack);
			//alert(t)
		}
		else if(t=='jpg')
		{
			//jet.loadImage(config.url,config.callBack);
			jet.loadImage(config);
		}
		
		
	}
	//alert('d')
	//jet.console.info('sd2');
},


/*
 * 功能：组件加载，文件加载 （仅js,css可跨域）
 * 示例：
 *                            单个文件加载：jet.superLoad({url:'/path/xx.js',callBack:fn3,id:'tid'});
 * 多个文件加载（每个文件加载完就回调函数）：jet.superLoad([{url:'/path/xx.jsp',callBack:fn3},{url:'/path/xx.css',callBack:fn3}]);
 * 多个文件加载（所有文件加载完才回调函数）：jet.superLoad({url:['/path/xx.js','/path/xx.js1','/path/xx.js'],callBack:fn3});  
 * 返回值：无
 * 参数：
 * options 可选 (对象)
 * 选项：
 * url:要加载的文件url 
 * callBack:加载成功回调函数
 * id:如果是加载html 加载成功后填充到该id指定的元素里
 */

superLoad:function(options){
	
	//var config = jQuery.extend({}, defaults, options);
	if(jQuery.isArray(options))
	{
	
		jQuery.each(options,function(i,n){
		jet.load(n);
	    
	});
	
	}
	else
	{
		jet.load(options);
	}
		
	
}
	
	
};

function swfShow(url){
	/*
	功能:flash插件
	参数：
	url:(str) flash调用文件路径，注意flash的扩展名  .swf 不用填写
	使用示例：
	swfShow('/swf/v2012/ad/mzone');
	*/
	AC_FL_RunContent( "src",url,"quality", "high","bgcolor", "#FFFFF","wmode","transparent","name", "mobileStore","allowScriptAccess","sameDomain","type", "application/x-shockwave-flash","pluginspage", "https://www.adobe.com/go/getflashplayer");
}

/*
	功能:flash插件
	*/

var isIE  = (navigator.appVersion.indexOf("MSIE") != -1) ? true : false;
var isWin = (navigator.appVersion.toLowerCase().indexOf("win") != -1) ? true : false;
var isOpera = (navigator.userAgent.indexOf("Opera") != -1) ? true : false;

function ControlVersion()
{
	var version;
	var axo;
	var e;

	// NOTE : new ActiveXObject(strFoo) throws an exception if strFoo isn't in the registry

	try {
		// version will be set for 7.X or greater players
		axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash.7");
		version = axo.GetVariable("$version");
	} catch (e) {
	}

	if (!version)
	{
		try {
			// version will be set for 6.X players only
			axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash.6");
			
			// installed player is some revision of 6.0
			// GetVariable("$version") crashes for versions 6.0.22 through 6.0.29,
			// so we have to be careful. 
			
			// default to the first public version
			version = "WIN 6,0,21,0";

			// throws if AllowScripAccess does not exist (introduced in 6.0r47)		
			axo.AllowScriptAccess = "always";

			// safe to call for 6.0r47 or greater
			version = axo.GetVariable("$version");

		} catch (e) {
		}
	}

	if (!version)
	{
		try {
			// version will be set for 4.X or 5.X player
			axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash.3");
			version = axo.GetVariable("$version");
		} catch (e) {
		}
	}

	if (!version)
	{
		try {
			// version will be set for 3.X player
			axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash.3");
			version = "WIN 3,0,18,0";
		} catch (e) {
		}
	}

	if (!version)
	{
		try {
			// version will be set for 2.X player
			axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash");
			version = "WIN 2,0,0,11";
		} catch (e) {
			version = -1;
		}
	}
	
	return version;
}

// JavaScript helper required to detect Flash Player PlugIn version information
function GetSwfVer(){
	// NS/Opera version >= 3 check for Flash plugin in plugin array
	var flashVer = -1;
	
	if (navigator.plugins != null && navigator.plugins.length > 0) {
		if (navigator.plugins["Shockwave Flash 2.0"] || navigator.plugins["Shockwave Flash"]) {
			var swVer2 = navigator.plugins["Shockwave Flash 2.0"] ? " 2.0" : "";
			var flashDescription = navigator.plugins["Shockwave Flash" + swVer2].description;
			var descArray = flashDescription.split(" ");
			var tempArrayMajor = descArray[2].split(".");			
			var versionMajor = tempArrayMajor[0];
			var versionMinor = tempArrayMajor[1];
			var versionRevision = descArray[3];
			if (versionRevision == "") {
				versionRevision = descArray[4];
			}
			if (versionRevision[0] == "d") {
				versionRevision = versionRevision.substring(1);
			} else if (versionRevision[0] == "r") {
				versionRevision = versionRevision.substring(1);
				if (versionRevision.indexOf("d") > 0) {
					versionRevision = versionRevision.substring(0, versionRevision.indexOf("d"));
				}
			}
			var flashVer = versionMajor + "." + versionMinor + "." + versionRevision;
		}
	}
	// MSN/WebTV 2.6 supports Flash 4
	else if (navigator.userAgent.toLowerCase().indexOf("webtv/2.6") != -1) flashVer = 4;
	// WebTV 2.5 supports Flash 3
	else if (navigator.userAgent.toLowerCase().indexOf("webtv/2.5") != -1) flashVer = 3;
	// older WebTV supports Flash 2
	else if (navigator.userAgent.toLowerCase().indexOf("webtv") != -1) flashVer = 2;
	else if ( isIE && isWin && !isOpera ) {
		flashVer = ControlVersion();
	}	
	return flashVer;
}

// When called with reqMajorVer, reqMinorVer, reqRevision returns true if that version or greater is available
function DetectFlashVer(reqMajorVer, reqMinorVer, reqRevision)
{
	versionStr = GetSwfVer();
	if (versionStr == -1 ) {
		return false;
	} else if (versionStr != 0) {
		if(isIE && isWin && !isOpera) {
			// Given "WIN 2,0,0,11"
			tempArray         = versionStr.split(" "); 	// ["WIN", "2,0,0,11"]
			tempString        = tempArray[1];			// "2,0,0,11"
			versionArray      = tempString.split(",");	// ['2', '0', '0', '11']
		} else {
			versionArray      = versionStr.split(".");
		}
		var versionMajor      = versionArray[0];
		var versionMinor      = versionArray[1];
		var versionRevision   = versionArray[2];

        	// is the major.revision >= requested major.revision AND the minor version >= requested minor
		if (versionMajor > parseFloat(reqMajorVer)) {
			return true;
		} else if (versionMajor == parseFloat(reqMajorVer)) {
			if (versionMinor > parseFloat(reqMinorVer))
				return true;
			else if (versionMinor == parseFloat(reqMinorVer)) {
				if (versionRevision >= parseFloat(reqRevision))
					return true;
			}
		}
		return false;
	}
}

function AC_AddExtension(src, ext)
{
  if (src.indexOf('?') != -1)
    return src.replace(/\?/, ext+'?'); 
  else
    return src + ext;
}

function AC_Generateobj(objAttrs, params, embedAttrs) 
{ 
  var str = '';
  if (isIE && isWin && !isOpera)
  {
    str += '<object ';
    for (var i in objAttrs)
    {
      str += i + '="' + objAttrs[i] + '" ';
    }
    str += '>';
    for (var i in params)
    {
      str += '<param name="' + i + '" value="' + params[i] + '" /> ';
    }
    str += '</object>';
  }
  else
  {
    str += '<embed ';
    for (var i in embedAttrs)
    {
      str += i + '="' + embedAttrs[i] + '" ';
    }
    str += '> </embed>';
  }

  document.write(str);
}

function AC_FL_RunContent(){
  var ret = 
    AC_GetArgs
    (  arguments, ".swf", "movie", "clsid:d27cdb6e-ae6d-11cf-96b8-444553540000"
     , "application/x-shockwave-flash"
    );
  AC_Generateobj(ret.objAttrs, ret.params, ret.embedAttrs);
}

function AC_SW_RunContent(){
  var ret = 
    AC_GetArgs
    (  arguments, ".dcr", "src", "clsid:166B1BCA-3F9C-11CF-8075-444553540000"
     , null
    );
  AC_Generateobj(ret.objAttrs, ret.params, ret.embedAttrs);
}

function AC_GetArgs(args, ext, srcParamName, classid, mimeType){
  var ret = new Object();
  ret.embedAttrs = new Object();
  ret.params = new Object();
  ret.objAttrs = new Object();
  for (var i=0; i < args.length; i=i+2){
    var currArg = args[i].toLowerCase();    

    switch (currArg){	
      case "classid":
        break;
      case "pluginspage":
        ret.embedAttrs[args[i]] = args[i+1];
        break;
      case "src":
      case "movie":	
        args[i+1] = AC_AddExtension(args[i+1], ext);
        ret.embedAttrs["src"] = args[i+1];
        ret.params[srcParamName] = args[i+1];
        break;
      case "onafterupdate":
      case "onbeforeupdate":
      case "onblur":
      case "oncellchange":
      case "onclick":
      case "ondblClick":
      case "ondrag":
      case "ondragend":
      case "ondragenter":
      case "ondragleave":
      case "ondragover":
      case "ondrop":
      case "onfinish":
      case "onfocus":
      case "onhelp":
      case "onmousedown":
      case "onmouseup":
      case "onmouseover":
      case "onmousemove":
      case "onmouseout":
      case "onkeypress":
      case "onkeydown":
      case "onkeyup":
      case "onload":
      case "onlosecapture":
      case "onpropertychange":
      case "onreadystatechange":
      case "onrowsdelete":
      case "onrowenter":
      case "onrowexit":
      case "onrowsinserted":
      case "onstart":
      case "onscroll":
      case "onbeforeeditfocus":
      case "onactivate":
      case "onbeforedeactivate":
      case "ondeactivate":
      case "type":
      case "codebase":
      case "id":
        ret.objAttrs[args[i]] = args[i+1];
        break;
      case "width":
      case "height":
      case "align":
      case "vspace": 
      case "hspace":
      case "class":
      case "title":
      case "accesskey":
      case "name":
      case "tabindex":
        ret.embedAttrs[args[i]] = ret.objAttrs[args[i]] = args[i+1];
        break;
      default:
        ret.embedAttrs[args[i]] = ret.params[args[i]] = args[i+1];
    }
  }
  ret.objAttrs["classid"] = classid;
  if (mimeType) ret.embedAttrs["type"] = mimeType;
  return ret;
}


/*
	功能：
	图片按需加载
	选项：
	placeholder:(str) 用图片提前占位,值为某一图片路径.此图片用来占据将要加载的图片的位置,待图片加载时,占位图则会隐藏
	effect:(str) 这里做了特别处理，由于ie8以上效果不能显示，所以定义了一个变量，showeffect，判断为IE8以下，包括IE8时为没有特效，	effect(特效),值有show(直接显示),fadeIn(淡入),slideDown(下拉)等,常用fadeIn
	threshold:(int) 值为数字,代表页面高度.如设置为200,表示滚动条在离目标位置还有200的高度时就开始加载图片,可以做到不让用户察觉
	event:(evt) 值有click(点击),mouseover(鼠标划过),sporty(运动的),foobar(…).可以实现鼠标莫过或点击图片才开始加载,后两个值未测试
	container:(obj)  对某容器中的图片实现效果,值为某容器.lazyload默认在拉动浏览器滚动条时生效,这个参数可以让你在拉动某DIV的滚动条时依次加载其中的图片 如：$("#container")
	failurelimit:(int) 图片排序混乱时，lazyload默认在找到第一张不在可见区域里的图片时则不再继续加载,但当HTML容器混乱的时候可能出现可见区域内图片并没加载出来的情况,failurelimit意在加载N张可见区域外的图片,以避免出现这个问题.
	使用示例:
	<ul>
		<li><img src="/images/v2012/public/bank/icon_bank_01.gif" alt="中国工商银行" /></li>
		<li><img src="/images/v2012/public/bank/icon_bank_12.gif" alt="中国农业银行" /></li>
		<li><img src="/images/v2012/public/bank/icon_bank_02.gif" alt="中国建设银行"/></li>
		<li><img src="/images/v2012/public/bank/icon_bank_16.gif" alt="华夏银行" /></li>
	</ul>
	$(function(){
	$("img").lazyload({
	  effect:showeffect,
	  failurelimit:10
	  });
	});
*/
eval(function(p,a,c,k,e,d){e=function(c){return(c<a?'':e(parseInt(c/a)))+((c=c%a)>35?String.fromCharCode(c+29):c.toString(36))};if(!''.replace(/^/,String)){while(c--){d[e(c)]=k[c]||e(c)}k=[function(e){return d[e]}];e=function(){return'\\w+'};c=1};while(c--){if(k[c]){p=p.replace(new RegExp('\\b'+e(c)+'\\b','g'),k[c])}}return p}('(5($){$.J.L=5(r){8 1={d:0,A:0,b:"h",v:"N",3:4};6(r){$.D(1,r)}8 m=9;6("h"==1.b){$(1.3).p("h",5(b){8 C=0;m.t(5(){6(!$.k(9,1)&&!$.l(9,1)){$(9).z("o")}j{6(C++>1.A){g B}}});8 w=$.M(m,5(f){g!f.e});m=$(w)})}g 9.t(5(){8 2=9;$(2).c("s",$(2).c("i"));6("h"!=1.b||$.k(2,1)||$.l(2,1)){6(1.u){$(2).c("i",1.u)}j{$(2).K("i")}2.e=B}j{2.e=x}$(2).T("o",5(){6(!9.e){$("<V />").p("X",5(){$(2).Y().c("i",$(2).c("s"))[1.v](1.Z);2.e=x}).c("i",$(2).c("s"))}});6("h"!=1.b){$(2).p(1.b,5(b){6(!2.e){$(2).z("o")}})}})};$.k=5(f,1){6(1.3===E||1.3===4){8 7=$(4).F()+$(4).O()}j{8 7=$(1.3).n().G+$(1.3).F()}g 7<=$(f).n().G-1.d};$.l=5(f,1){6(1.3===E||1.3===4){8 7=$(4).I()+$(4).U()}j{8 7=$(1.3).n().q+$(1.3).I()}g 7<=$(f).n().q-1.d};$.D($.P[\':\'],{"Q-H-7":"$.k(a, {d : 0, 3: 4})","R-H-7":"!$.k(a, {d : 0, 3: 4})","S-y-7":"$.l(a, {d : 0, 3: 4})","q-y-7":"!$.l(a, {d : 0, 3: 4})"})})(W);',62,62,'|settings|self|container|window|function|if|fold|var|this||event|attr|threshold|loaded|element|return|scroll|src|else|belowthefold|rightoffold|elements|offset|appear|bind|left|options|original|each|placeholder|effect|temp|true|of|trigger|failurelimit|false|counter|extend|undefined|height|top|the|width|fn|removeAttr|lazyload|grep|show|scrollTop|expr|below|above|right|one|scrollLeft|img|jQuery|load|hide|effectspeed'.split('|'),0,{}));
var showeffect;
if("\v"=="v"){	// 这个判断真的只有在IE下才为真，包括IE 8
	showeffect="show";	//这里做了特别处理，由于ie8以上效果不能显示，所以定义了一个变量，showeffect，判断为IE8以下，包括IE8时为没有特效
}else{
	showeffect="fadeIn";
}





/*
 * iframe自适应高度
 */


function reinitIframe(o){
	
	var iframe = $(o).attr({scrolling:"no",frameborder:"0"});
	iframe = iframe[0];
	//scrolling="no" frameborder="0"
	try{
	iframe.scrolling = 'no';
	iframe.frameBorder = 0;
	iframe.style.height =  0+'px';
	//iframe.style.tableLayout='fixed';
	
	//var bHeight = iframe.contentWindow.document.body.scrollHeight;
	
	//var dHeight = iframe.contentWindow.document.documentElement.scrollHeight;
	
	//var height = Math.max(bHeight,dHeight);
	
	var height = $(iframe.contentWindow.document).height();
	iframe.style.height =  height+'px';
	iframe=null;
	delete iframe;
	if ($.browser.msie&&CollectGarbage) {
            CollectGarbage(); //IE 特有 释放内存
        }
	}catch (e){}

}

function mulReinitIframe(expr){	

	//return null;
	var k=0;//检测10次以上没找个符合的对象，即清除mySetTimeout
	var mySetTimeout;
	var iframe = null;
	function _setTimeOut(){			
		try{
			
				if(mySetTimeout){clearTimeout(mySetTimeout);}
				
				if ($.browser.msie&&CollectGarbage) {
                    CollectGarbage(); //IE 特有 释放内存
                }
			
			}catch(e){}
		
		
		iframe = $(expr);
		if(iframe.length==0)
		{
			
			k=k+1;
			if(k==11)
			{
				try{
					if(mySetTimeout){clearTimeout(mySetTimeout);}					
					if ($.browser.msie&&CollectGarbage) {
	                    CollectGarbage(); //IE 特有 释放内存
	                }					
				}catch(e){}
				
				iframe = null;
				delete iframe;
				try
				{
					if ($.browser.msie&&CollectGarbage) {
	                    CollectGarbage(); //IE 特有 释放内存
	                }
				}
				catch(e){}
			}
			
			return;
		}
		
		var _iframe = $(expr+':visible');
		if(_iframe.length>0)
		{
			$.each(_iframe,function(i,n){
			reinitIframe(n);	
			if(i==_iframe.length-1)
			{
				iframe=null;
				delete iframe;
				try
				{
					if ($.browser.msie&&CollectGarbage) {
	                    CollectGarbage(); //IE 特有 释放内存
	                }
				}
				catch(e){}
				mySetTimeout = window.setTimeout(_setTimeOut,200);
			}
			});
		}
		else
		{
			
			mySetTimeout = window.setTimeout(_setTimeOut,200);
		}
		
	
	}
	
	
	mySetTimeout = window.setTimeout(_setTimeOut,200);
	
	
}







var jet = {
	
/*
 * 功能：判断请求文件类型
 * 示例：jet.getfileType('/path/kk.js')
 * 返回值: 
 * 		js文件 :js	
 * 		css文件:css
 * 		图片   :jpg
 * 		html   :html
 * 		其它   :url
 */


getfileType:function(f)
	{
		var _f= jQuery.trim(f).toLocaleLowerCase();		
		var m=Math.min(_f.indexOf('?')==-1?0:_f.indexOf('?'),_f.indexOf('#')==-1?0:_f.indexOf('#'));
		var d=m==0?(_f.length-3):(m-3);	
		var url = _f.slice(d,d+3);
		
		var re='url';
		switch(url)
		{			
			case 'jpg':
			case 'gif':
			case 'png':		
			re='jpg';
			break;
			case 'css':
			re = 'css';
			break;
			case '.js':
			re = 'js';
			break;
			case 'htm':
			case 'tml':			
			re = "html";
			break;
			default:
			re = 'url';			
			
		}
		return re;
	
		
	},


loadJs:function(options){
	/*功能：js加载
	 *参数说明：
	 *url要加载的js URL
	 *callBack 加载完后的回调函数
	 *id js的id
	 */
	
	var defaults={
		url:'',		
		callBack:null,
		id:''
	};
	var config = jQuery.extend({}, defaults, options);
	
	
	
	var callBack = config.callBack;
	var _callBack = function(){};
	
	if(callBack!=null)//如果有回调函数，执行之 
			{
			  if(typeof(callBack)=="string"){//如果回调方法传入为字符串类型
				_callBack = function(){
					eval(callBack);	
				}	
				}else{
					_callBack = function(){
						//alert(33)
					callBack();
					}
				}
			}
	
	//查找是否已经加载过	
	var isLoad = false;
	var arrJs= jQuery('script');
	jQuery.each(arrJs,function(i,n){		
		
		if(n.src==config.url)
		{
			isLoad=true;
			return false;
		}
		
	});
	if(isLoad){
		_callBack();
		return;
	}
	
	
	var _doc = document.getElementsByTagName('head')[0];
	//没找到head元素或者url为空 直接返回
	if(_doc==undefined||config.url=='')
	{
		return false;
	}
	
    var js = document.createElement('script');
    js.setAttribute('type','text/javascript');
    js.setAttribute('src',config.url);
	js.setAttribute('id',config.id);
	js.setAttribute('isLoad','no');
    _doc.appendChild(js);
	
	
	
    if (!/*@cc_on!@*/0) { //if not IE
        //Firefox2、Firefox3、Safari3.1+、Opera9.6+ support js.onload
        js.onload = function () {
            //alert('Firefox2、Firefox3、Safari3.1+、Opera9.6+ support js.onload');
			js.setAttribute('isLoad','yes');
		 _callBack();
			
        }
    } else {
        //IE6、IE7 support js.onreadystatechange
        js.onreadystatechange = function () {
            if (js.readyState == 'loaded' || js.readyState == 'complete') {
                //alert('IE6、IE7 support js.onreadystatechange');
			js.setAttribute('isLoad','yes');
			_callBack();
				
            }
        }
    }

    return false;

	
},

loadImage:function(options) {
	/*功能：图片加载
	 *参数说明：
	 *url要加载的图片URL
	 *callBack 加载完后的回调函数
	 */
	
	var defaults={
		url:'',		
		callBack:null,
		id:''
	};
	var config = jQuery.extend({}, defaults, options);
	// alert(33)
	if(config.url=='')return;
	 //alert(33)
    var img = new Image(); //创建一个Image对象，实现图片的预下载
    img.src = config.url;
      
   	var callBack = config.callBack;
	var _callBack = function(){};
	if(callBack!=null)//如果有回调函数，执行之 
		{
		  if(typeof(callBack)=="string"){//如果回调方法传入为字符串类型
			_callBack = function(){
				if(config.id!=''&&jQuery('#'+config.id).length>0)
				{
					jQuery('#'+config.id).attr("src",config.url);
				}
				eval(callBack);	
			}	
			}else{
				_callBack = function(){
				if(config.id!=''&&jQuery('#'+config.id).length>0)
				{
					jQuery('#'+config.id).attr("src",config.url);
				}
				callBack();
				}
			}
		}
   
  
    if (img.complete) { // 如果图片已经存在于浏览器缓存，直接调用回调函数
        _callBack.call(img);
		//_callBack();
        return; // 直接返回，不用再处理onload事件
    }

    img.onload = function() { //图片下载完毕时异步调用callBack函数。
        _callBack.call(img);//将回调函数的this替换为Image对象
       // _callBack();
    };
	//img = null;
},
	
/*
 * 功能：加载css 文件
 * 示例：jet.loadCss('/path/xxx.css')
 */
 
	
loadCss:function(options){
	var head=document.getElementsByTagName('head')[0];
	var defaults={
			url:'',		
			callBack:null,
			id:''
		};
	var config = jQuery.extend({}, defaults, options);

	//没找到head元素或者url为空 直接返回
	if(head==undefined||config.url=='')
	{
		return false;
	}
	

	//查找是否已经加载过	
	var isLoad = false;
	var arrCss= jQuery('link');
	jQuery.each(arrCss,function(i,n){		
		
		if(n.src==config.url)
		{
			isLoad=true;
			return false;
		}
		
	});
	if(isLoad){
		//_callBack();
		return;
	}
	
	
	//alert(2)
	var style=document.createElement('link');
	style.rel='stylesheet';
	style.type='text/css';
	style.href=config.url;
	style.id = config.id;
	head.appendChild(style);


 	var callBack = config.callBack;	
	if(callBack!=null)//如果有回调函数，执行之 
		{
		  if(typeof(callBack)=="string"){//如果回调方法传入为字符串类型
			eval(callBack);		
			}else
			{				
				callBack();
			}
		}
	
},	

/*
 * 功能:文件加载
 * 示例:
 * jet.load({url:'/path/xx.shtml',callBack:fn3,id:'inerId'})
 * jet.load({url:['/path/xx.shtml','/path/xx1.shtml','/path/xx2.shtml'],callBack:fn3,id:'inerId'})
 * 参数：
 * 		url:参数为要加载的文件url
 * callBack:加载成功后的回调函数
 * 		 id:要填入内容的元素ID（仅加载html文件和返回html或文本才生效）
 */

load:function(options){
	var defaults={
		url:'',		
		callBack:null,
		id:''
	};
	var config = jQuery.extend({}, defaults, options);
	
	if(jQuery.isArray(config.url))
	{
		var _length = config.url.length;
		if(_length>0)
		{
			var k = 0;
		function  xload(){
			if(k==_length){return;}
			
			var _config = config.url[k];
			if(k!=(_length-1 ))
			{
				jet.load({url:_config});
				
			}
			else
			{
				//jet.load({url:n.url});
				var thisurl ='',thisid='';
				//var _thisCallBack = function(){};
				/*
				if(jQuery.isPlainObject(_config))
				{
					thisurl = _config.url;
					thisid = config.id||'';
			
					var myCallBack =_config.callBack;
					if(typeof(myCallBack)=="string")	
					{
						_thisCallBack = function(){
							eval(myCallBack);
						};
					}
					else if(myCallBack!=null)
					{
						_thisCallBack = function(){
							myCallBack();
						};
					}
					
					
				}*/
				//else
				//{
				thisid = config.id||'';	thisurl = _config;
				//}
				
				
				var thisCallBack =function(){}; //总的callBack
				var _callBack = config.callBack;
				if(_callBack!=null)
				{
					if(typeof(_callBack)=="string")					
					{						
						thisCallBack = function(){//如果回调方法传入为字符串类型	
							//_thisCallBack();	
							eval(_callBack);	
						};
					}
				else
					{
						thisCallBack = function()
						{		
							//_thisCallBack();		
							_callBack();
						};						
					
					}
				}
				
				jet.load({url:thisurl,callBack:thisCallBack,id:thisid});
				//alert(thisid)
				
		}
			
		k++;
			
		xload();	
		}
		
		xload();
		}
		
	}
	else if(!!config.url)
	{
		//alert('fsd')
		//jet.console.info('sd');
		
		var t = jet.getfileType(config.url);
		
		if(t=='js')
		{
			//jQuery.getScript(config.url,config.callBack);
			jet.loadJs(config);

		}
		else if(t=='htm'||t=='url')
		{
			if(!!config.id)
			{
				$('#'+config.id).load(config.url,config.callBack);
			}
			else
			{
				$.get(config.url,config.callBack);
			}
		}
		else if(t=='css')
		{
			jet.loadCss(config)
			//$.get(config.url,config.callBack);
			//alert(t)
		}
		else if(t=='jpg')
		{
			//jet.loadImage(config.url,config.callBack);
			jet.loadImage(config);
		}
		
		
	}
	//alert('d')
	//jet.console.info('sd2');
},


/*
 * 功能：组件加载，文件加载 （仅js,css可跨域）
 * 示例：
 *                            单个文件加载：jet.superLoad({url:'/path/xx.js',callBack:cal,id:'tid'});
 *                               加载HTML:jet.superLoad({url:'/path/xx.html',callBack:cal,id:'tid'});
 * 多个文件加载（每个文件加载完就回调函数）：jet.superLoad([{url:'/path/xx.jsp',callBack:cal},{url:'/path/xx.css',callBack:fn1}]);
 * 多个文件加载（所有文件加载完才回调函数）：jet.superLoad({url:['/path/xx.js','/path/xx.js1','/path/xx.js'],callBack:fn1});  
 * 返回值：无
 * 参数：
 * options 可选 (对象)
 * 选项：
 * url:要加载的文件url 
 * callBack:加载成功回调函数
 * id:如果是加载html 加载成功后填充到该id指定的元素里
 */

superLoad:function(options){
	
	//var config = jQuery.extend({}, defaults, options);
	//alert(typeof(options));
	if(jQuery.isArray(options))
	{
	
	/*
		jQuery.each(options,function(i,n){
		jet.load(n);
	    
	});
	*/
	
	
	var olength = options.length;
	var k = 0;	
	if(olength>0)
	{
		function innerLoad(){
			
			if(k==olength){return;}
			jet.load(options[k]);
			k++;
			innerLoad();
		}
		innerLoad();
	}
	
	
	
	}
	else if(jQuery.isPlainObject(options))
	{
		jet.load(options);
	}else if(typeof(options)=="string")
	{
		jet.load({url:options});
		
		//alert(typeof(options)=="string")
	}else
	{
		//alert(typeof(opitons));
		return;
	}
		
	//alert(options.url)
}
	
};
window.loadFile = jet.superLoad;//文件加载方法


